基本原理 从序列中任选一个数作为“基准”；所有小于“基准”的数，都挪到“基准”的左边；所有大于等于“基准”的数，都挪到“基准”的右边。 在这次移动结束之后，该“基准”就处于两个序列的中间位置，不再参与后续的排序；针对“基准”左边和右边的两个子
其实快速排序算法也可以理解为相邻两个比大小，然后换位置。将两个指针i，j分别指向表的起始和最后的位置。
假设用户输入了如下数组： 下标 0 1 2 3 4 5 数据 6 2 7 3 8 9 创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找
反复操作以下两步：
一、冒泡排序法待排序的数据source=>6,2,8,4,0,9,3,5,1,7排序后的数据sort=>0,1,2,3,4,5,6,7,8,9二、选择排序法待排序的数据：source=>12,54,65,2,3,40,91,7,321,50排序后的数据：sort=>02,3,7,12,40,50,54,65,91,321三、Shell排序法待排序的数
（1）j逐渐减小，并逐次比较j指向的元素和目标元素的大小，若p(j)<T则交换位置。
时间复杂度为O(nlogn) n为元素个数 1. 快速排序的三个步骤： 1.1. 找到序列中用于划分序列的元素 1.2. 用元素划分序列 1.3. 对划分后的两个序列重复1,2两个步骤指导序列无法再划分 所以对于n个元素其排序时间为 T(n) = 2*T(n/2) + n （表示将长
（2）i逐渐增大，并逐次比较i指向的元素和目标元素的大小，若p(i)>T则交换位置。
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace test{ class QuickSort { static void Main(string[] args) { int[] array = { 49, 38, 65, 97, 76, 13, 27 }; sort(array, 0, array.Lengt
直到i，j指向同一个值，循环结束。
C语言程序： /* 快 速 排 序 */ #include "stdio.h" void QuickSort(int e[], int first, int end) { int i=first,j=end,temp=e[first]; while(i
方法
首先设置两个变量i，j。
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也
分别指向（代表）序列的首尾元素。
首先它是一种排序算法，排序算法是为了让无序的数据组合变成有序的数据组合。 有序的数据组合最大的优势是在于当你进行数据定位和采用时， 会非常方便，因为这个数据是有序的 从而在代码设计的时候会让你避免很多不必要的麻烦， 因为无序数据你
就是以第一个元素为基准，从小到大进行排列。
http://v.youku.com/v_show/id_XMjk2NzI4OTky.html 排序算法演示, 相信你再也找不到比这个还好的动画演示了.
让j从后向前进行查询，直到找到第一个小于66的元素。
1、“快速排序法”使用的是递归原理，下面一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的值
则将最后一个j指向的数23，和i指向的66交换位置。
0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。其中关键值key=a[low]。用题目给定的数组模拟第一趟排
然后将i从前向后查询，直到找到第一个大于66的元素76.
给个快速排序你参考参考 /********************** 快速排序 ****************************基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录）， 以该记录为基准，将当前的无序区划分为左右两个较小的无 序子区，使左边的记录均小于
将76和66位置互换。
快速排序的分割宗旨就是 1.在待排序序列中选定一个值 pivot 2.通过一轮快排，将小于pivot的值丢到其左边，大于pivot的值丢到其右边 3.以pivot为界，分割该序列，递归调用快排算法 int Partition ( SortData V[ ], int low, int high ) { int piv
让j从后向前进行查询，直到找到第一个小于66的元素57
#include using std::cout; using std::endl; int Partition( int *R, int low, int high){ // 对记录子序列 R[low..high] 进行一趟快速排序，并返回枢轴记录 // 所在位置，使得在它之前的记录的关键字均不大于它的关键字， // 而在它之后的记录
将57和66交换位置。
最坏情况下，是整个序列都已经有序或完全倒序 此时，快速排序退化为冒泡排序，要比较n2次才能完成
然后将i从前向后查询，直到找到第一个大于66的元素81.
/* php中的快速排序，并且倒序输出 */ function quickSort($array) { if(!isset($array[1])) return $array; $mid = $array[0]; //获取一个用于分割的关键字，一般是首个元素 $leftArray = array(); $rightArray = array(); foreach($array as $
将81和66交换位置。
这不是一样的吗？ 递归也是一样的输出哦。 在do{}while()；之后循环把数组的打印出来不就行了。 for(int mm =low; mm
让j从后向前进行查询，直到找到第一个小于66的元素26
先说一下快速排序中最好的排序情况，最好的情况下，每次进行一次分区，我们会把一个序列刚好分为几近相等的两个子序列，这个情况也每次递归调用的是时候也就刚好处理一半大小的子序列。这看起来其实就是一个完全二叉树，树的深度为 O(logn)，所
将26和66交换位置。
打你，这么简单的问题都不认真研究一下。 冒泡排序是最慢的排序，时间复杂度是 O(n^2)。 快速排序是最快的排序。关于快速排序，我推荐你看看《代码之美》第二章：我编写过的最漂亮的代码。作者所说的最漂亮，就是指效率最高的。 -----------
此时i，j都同时指向了目标元素66.
快速排序法”使用的是递归原理，下面我结合一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的
查找停止。
所得到的序列就是第一趟排序的序列
#include int partions(int l[],int low,int high) { int prvotkey=l[low]; l[0]=l[low]; while (low
扩展阅读，以下内容您可能还感兴趣。
用C语言编写一个快速排序算法 输入10个数
1、“快速排序法”使用的是递归原理，下面一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的值比它大。{21，12，32， 46，18，53，80，72，63，98}，这样一个数组的排序就变成了两个小数组的排序--53左边的数组和53右边的数组，而这两个数组继续用同样的方式继续下去，一直到顺序完全正确。一般来说，冒泡法是程序员最先接触的排序方法，它的优点是原理简单，编程实现容易，但它的缺点就是速度太慢。
2、快速排序代码：#include<stdio.h>
void quicksort(int a[],int left,int right)
{
int i,j,temp;
i=left;
j=right;
temp=a[left];
if(left>right)
return;
while(i!=j)
{
while(a[j]>=temp&&j>i)
j--;
if(j>i)
a[i++]=a[j];
while(a[i]<=temp&&j>i)
i++;
if(j>i)
a[j--]=a[i];
}
a[i]=temp;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
void main()
{
int a[]={53,12,98,63,18,72,80,46,32,21};
int i;
quicksort(a,0,9);
/*排好序的结果*/
for(i=0;i<10;i++)
printf("%4dn",a[i]);
}
C语言，快速排序算法
0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。
其中关键值key=a[low]。
用题目给定的数组模拟第一趟排序如下：
下标 0 1 2 3 4 5 6 7 8 9
值 9 16 47 82 4 66 12 3 25 51
low=0 high=9
part_element=a[low]=9
进入for循环
进入第一个while
part_element<51，于是high--,high=8;
part_element<25，high--,high=7;
part_element>3,不满足，结束while
a[low]=a[0]=a[high]=a[7]=3,low++,low=1;
进入第二个while
part_element<16,不满足，结束while
a[high]=a[7]=a[low]=a[1]=16,high--,high=6
for第一个循环结束，数组如下
3 16 47 82 4 66 12 16 25 51
low=1,high=6
for第二个循环同上，结束时数组如下
3 4 47 82 47 66 12 16 25 51
low=2,high=3
for第三个循环，第一个while中high--以后，low==high，直接break跳出for循环，此时
3 4 47 82 47 66 12 16 25 51
low=2,high=2
结束for以后
a[high]=a[2]=part_element=9,得到
3 4 9 82 47 66 12 16 25 51
split函数return high=2
quicksort函数中middle=2;
下面两句递归，仍然是调用split函数，对数组
0-2,3-9两部分分别重复上述操作
最后直到数组数据有序
用C语言编程实现快速排序算法
给个快速排序你参考参考
/********************** 快速排序 ****************************基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录），
以该记录为基准，将当前的无序区划分为左右两个较小的无
序子区，使左边的记录均小于基准值，右边的记录均大于或
等于基准值，基准值位于两个无序区的中间位置（即该记录
最终的排序位置）。之后，分别对两个无序区进行上述的划
分过程，直到无序区所有记录都排序完毕。
*************************************************************/
/*************************************************************
函数名称：static void swap(int *a, int *b)
参 数：int *a---整型指针
int *b---整型指针
功 能：交换两个整数的位置
返 回 值：无
说 明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
static void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int quickSortNum = 0; // 快速排序算法所需的趟数
/*************************************************************
函数名称：static int partition(int a[], int low, int high)
参 数：int a[]---待排序的数据
int low---无序区的下限值
int high---无序区的上限值
功 能：完成一趟快速排序
返 回 值：基准值的最终排序位置
说 明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
static int partition(int a[], int low, int high)
{
int privotKey = a[low]; //基准元素
while(low < high)
{ //从表的两端交替地向中间扫描
while(low < high && a[high] >= privotKey) // 找到第一个小于privotKey的值
high--; //从high所指位置向前搜索，至多到low+1位置
swap(&a[low], &a[high]); // 将比基准元素小的交换到低端
while(low < high && a[low] <= privotKey) // 找到第一个大于privotKey的值
low++; //从low所指位置向后搜索，至多到high-1位置
swap(&a[low], &a[high]); // 将比基准元素大的交换到高端
}
quickSortNum++; // 快速排序趟数加1
return low; // 返回基准值所在的位置
}
/*************************************************************
函数名称：void QuickSort(int a[], int low, int high)
参 数：int a[]---待排序的数据
int low---无序区的下限值
int high---无序区的上限值
功 能：完成快速排序算法，并将排序完成的数据存放在数组a中
返 回 值：无
说 明：使用递归方式完成
**************************************************************/
void QuickSort(int a[], int low, int high)
{
if(low < high)
{
int privotLoc = partition(a, low, high); // 将表一分为二
QuickSort(a, low, privotLoc-1); // 递归对低子表递归排序
QuickSort(a, privotLoc+1, high); // 递归对高子表递归排序
}
}
谁能仔细说说这段快速排序算法分割怎么回事
快速排序的分割宗旨就是
1.在待排序序列中选定一个值 pivot
2.通过一轮快排，将小于pivot的值丢到其左边，大于pivot的值丢到其右边
3.以pivot为界，分割该序列，递归调用快排算法
int Partition ( SortData V[ ], int low, int high ) {
int pivotpos = low; //选择待排序序列的第一个数值为piovt
SortData pivot = V[low]; //得出pivot的值，存在SortData变量中
for ( int i = low+1; i <= high; i++ ) //开始循环
if ( V[i] < pivot ) { //如果遇到小于pivot的值，说明pivot的位置应该后移一位，因为已经找到一个比他小的了
pivotpos++; //pivot位置后移
if ( pivotpos != i )
Swap ( V[pivotpos], V[i] ); //交换两个值
}
Swap ( V[low], V[pivotpos] ); //交换两个值
return pivotpos; //完成排序，pivot前面都比他小，后面都比他大
}
如果你对于那两个交换是如何保证小的在前面，大的在后面有疑问的话
冷静下来手工操作一遍就明白了
如何理解快速排序算法的思想？
#include <iostream>
using std::cout;
using std::endl;
int Partition( int *R, int low, int high){
// 对记录子序列 R[low..high] 进行一趟快速排序，并返回枢轴记录
// 所在位置，使得在它之前的记录的关键字均不大于它的关键字，
// 而在它之后的记录的关键字均不小于它的关键字
R[0] = R[low]; // 将枢轴记录移至数组的闲置分量
int pivotkey = R[low]; // 枢轴记录关键字
cout << endl << "pivotkey : " << pivotkey << endl;
while(low < high){ // 从表的两端交替地向中间扫描
while( low<high && R[high]>=pivotkey ){
--high;
}
if(low < high){//需要进行这样的判断，如果是由于low>=high而退出的循环，不需要移动数据
R[low++] = R[high]; // 将比枢轴记录小的记录移到低端
//cout << "移动的hign数据：" << R[high] << endl;
}
while (low<high && R[low]<=pivotkey )
++low;
if(low < high){
R[high--] = R[low]; // 将比枢轴记录大的记录移到高端
//cout << "移动的low数据：" << R[low] << endl;
}
} // while
R[low] = R[0]; // 枢轴记录移到正确位置
//cout << "返回的pivotkey: " << low << endl;
for(int i = 1; i<=10; i++){
cout << R[i-1] << " ";
}
return low; // 返回枢轴位置
} // Partition
void QSort(int *R, int s, int t ){
// 对记录序列 R[s..t] 进行快速排序
if (s < t){ // 长度大于1
int pivotloc = Partition(R, s, t);// 对 R[s..t] 进行一趟快排，并返回枢轴位置
QSort(R, s, pivotloc-1);//对低子序列递归进行排序
QSort(R, pivotloc+1, t);//对高子序列递归进行排序
}//if
}//Qsort
int main(){
int li[10] = {0,38,65,97,76,13,27,48,55,4};
cout<<"注意:R[0]为数组的闲置分量"<<endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
QSort(li,1,9);
cout << endl;
for(int i = 1; i<=10; i++){
cout << li[i-1] << " ";
}
cout << endl;
return 0;
}
