快速排序

快速排序：

#include <iostream.h>

void run(int* pData,int left,int right)

{

int i,j;

int middle,iTemp;

i = left;

j = right;

middle = pData[(left+right)/2]; //求中间值

do{

while((pData[i]<middle) && (i<right))//从左扫描大于中值的数

i++;

while((pData[j]>middle) && (j>left))//从右扫描大于中值的数

j--;

if(i<=j)//找到了一对值

{

//交换

iTemp = pData[i];

pData[i] = pData[j];

pData[j] = iTemp;

i++;

j--;

}

}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）

//当左边部分有值(left<j)，递归左半边

if(left<j)

run(pData,left,j);

//当右边部分有值(right>i)，递归右半边

if(right>i)

run(pData,i,right);

}

void QuickSort(int* pData,int Count)

{

run(pData,0,Count-1);

}

void main()

{

int data[] = {10,9,8,7,6,5,4};

QuickSort(data,7);

for (int i=0;i<7;i++)

cout<<data[i]<<" ";

cout<<"\n";

}

这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的

情况

1.数组的大小是2的幂，这样分下去始终可以被2整除。假设为2的k次方，即k=log2(n)。

2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。

第一层递归，循环n次，第二层循环2*(n/2)......

所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n

所以算法复杂度为O(log2(n)*n)

其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么

他将变成交换法（由于使用了递归，情况更糟）。但是你认为这种情况发生的几率有多大？？

呵呵，你完全不必担心这个问题。实践证明，大多数的情况，快速排序总是最好的。

如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况

下速度要慢于快速排序（因为要重组堆）。