快速排序

快速排序

设要排序的数组是Arr[0]—–Arr[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动 , 因此，快速排序是不稳定的排序。

代码

int AdjustArray(int s[], int l, int r) //返回调整后基准数的位置  {      int i = l, j = r;      int x = s[l]; //s[l]即s[i]就是第一个坑      while (i < j)      {          // 从右向左找小于x的数来填s[i]          while(i < j && s[j] >= x)               j--;            if(i < j)           {              s[i] = s[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑              i++;          }          // 从左向右找大于或等于x的数来填s[j]          while(i < j && s[i] < x)              i++;            if(i < j)           {              s[j] = s[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑              j--;          }      }      //退出时，i等于j。将x填到这个坑中。      s[i] = x;      return i;  }  

再写分治法的代码：

void quick_sort1(int s[], int l, int r)  {      if (l < r)      {          int i = AdjustArray(s, l, r);//先成挖坑填数法调整s[]          quick_sort1(s, l, i - 1); // 递归调用           quick_sort1(s, i + 1, r);      }  }  

这样的代码显然不够简洁，对其组合整理下：

//快速排序  void quick_sort(int s[], int l, int r)  {      if (l < r)      {          //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1          int i = l, j = r, x = s[l];          while (i < j)          {              while(i < j && s[j] >= x) // 从右向左找第一个小于x的数                  j--;                if(i < j)                   s[i++] = s[j];              while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数                  i++;                if(i < j)                   s[j--] = s[i];          }          s[i] = x;          quick_sort(s, l, i - 1); // 递归调用           quick_sort(s, i + 1, r);      }  }  

Python递归：

#quick sortdef quickSort(L, low, high):    i = low     j = high    if i >= j:        return L    key = L[i]    while i < j:        while i < j and L[j] >= key:            j = j-1                                                                     L[i] = L[j]        while i < j and L[i] <= key:                i = i+1         L[j] = L[i]    L[i] = key     quickSort(L, low, i-1)    quickSort(L, j+1, high)    return L

时间复杂度：

排序算法的最坏情况运行时间为θ（n2），且最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候。
最好情况:如果每次划分过程产生的区间大小都为n/2，则快速排序法运行就快得多了。这时有：
T(n)=2T(n/2)+θ（n),T(1)=θ（1) (3):
解得：T(n)=θ（nlogn)
由于快速排序法也是基于比较的排序法，其运行时间为Ω（nlogn)，所以如果每次划分过程产生的区间大小都为n/2，则运行时间θ（nlogn）就是最好情况运行时间。
但是，是否一定要每次平均划分才能达到最好情况呢？要理解这一点就必须理解对称性是如何在描述运行时间的递归式中反映的。我们假设每次划分过程都产生9:1的划分，乍一看该划分很不对称。我们可以得到递归式：
T(n)=T(n/10)+T(9n/10)+θ（n),T(1)=θ（1) (4)
请注意树的每一层都有代价n，直到在深度log10n=θ（logn）处达到边界条件，以后各层代价至多为n。递归于深度log10/9n=θ（logn）处结束。这样，快速排序的总时间代价为T(n)=θ（nlogn），从渐进意义上看就和划分是在中间进行的一样。事实上，即使是99:1的划分时间代价也为θ（nlogn）。其原因在于，任何一种按常数比例进行划分所产生的递归树的深度都为θ（nlogn），其中每一层的代价为O(n），因而不管常数比例是什么，总的运行时间都为θ（nlogn），只不过其中隐含的常数因子有所不同。（关于算法复杂性的渐进阶，请参阅算法的复杂性)
平均情况
快速排序的平均运行时间为θ(nlogn)。
我们对平均情况下的性能作直觉上的分析。
要想对快速排序的平均情况有个较为清楚的概念，我们就要对遇到的各种输入作个假设。通常都假设输入数据的所有排列都是等可能的。后文中我们要讨论这个假设。
当我们对一个随机的输入数组应用快速排序时，要想在每一层上都有同样的划分是不太可能的。我们所能期望的是某些划分较对称，另一些则很不对称。事实上，我们可以证明，如果选择L[p..r]的第一个元素作为支点元素，Partition所产生的划分80%以上都比9:1更对称，而另20%则比9:1差，这里证明从略。