基本原理 从序列中任选一个数作为“基准”；所有小于“基准”的数，都挪到“基准”的左边；所有大于等于“基准”的数，都挪到“基准”的右边。 在这次移动结束之后，该“基准”就处于两个序列的中间位置，不再参与后续的排序；针对“基准”左边和右边的两个子

其实快速排序算法也可以理解为相邻两个比大小，然后换位置。将两个指针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;

}