快速排序算法

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

算法过程：

设要排序的数组是 A[0] …… A[N-1] ，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 　　一趟快速排序的算法是： 　　 1 ）设置两个变量 I 、 J ，排序开始的时候： I=0 ， J=N-1 ； 　　 2 ）以第一个数组元素作为关键数据，赋值给 key ，即 key=A[0] ； 　　 3 ）从 J 开始向前搜索，即由后开始向前搜索（ J=J-1 ），找到第一个小于 key 的值 A[J] ，并与 A[I] 交换； 　　 4 ）从 I 开始向后搜索，即由前开始向后搜索（ I=I+1 ），找到第一个大于 key 的 A[I] ，与 A[J] 交换； 　　 5 ）重复第 3 、 4 、 5 步，直到 I=J ； (3,4 步是在程序中没找到时候 j=j-1 ， i=i+1 ，直至找到为止。找到并交换的时候 i ， j 指针位置不变。另外当 i=j 这过程一定正好是 i+ 或 j- 完成的最后另循环结束 ) 　　例如：待排序的数组 A 的值分别是：（初始关键数据： X=49 ） 注意关键 X 永远不变，永远是和 X 进行比较，无论在什么位子，最后的目的就是把 X 放在中间，小的放前面大的放后面。 　　 A[0] 、 A[1] 、 A[2] 、 A[3] 、 A[4] 、 A[5] 、 A[6] ： 　　 49 38 65 97 76 13 27 　　进行第一次交换后： 27 38 65 97 76 13 49 　　 ( 按照算法的第三步从后面开始找 ) 　　进行第二次交换后： 27 38 49 97 76 13 65 　　 ( 按照算法的第四步从前面开始找 >X 的值， 65>49, 两者交换，此时： I=3 ) 　　进行第三次交换后： 27 38 13 97 76 49 65 　　 ( 按照算法的第五步将又一次执行算法的第三步从后开始找 　　进行第四次交换后： 27 38 13 49 76 97 65 　　 ( 按照算法的第四步从前面开始找大于 X 的值， 97>49, 两者交换，此时： I=4,J=6 ) 　　此时再执行第三步的时候就发现 I=J ，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是： 27 38 13 49 76 97 65 ，即所以大于 49 的数全部在 49 的后面，所以小于 49 的数全部在 49 的前面。 　　快速排序就是递归调用此过程——在以 49 为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组 A 的快速排序的全过程如图 6 所示： 　　初始状态 {49 38 65 97 76 13 27} 　　进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 　　分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。 　　 {76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。

 

Java
　　public class QuickSort { 　　
            public static void sort(Comparable[] data, int low, int high) { 　　
             // 枢纽元,一般以第一个元素为基准进行划分 　　
             int i = low; 　　
             int j = high; 　　
             if (low < high) { 　　

               // 从数组两端交替地向中间扫描 　　
              Comparable pivotKey = data[low];
　　
               // 进行扫描的指针i,j;i从左边开始,j从右边开始 　　
               while (i < j) { 　　
                 while (i < j && data[j].compareTo(pivotKey) > 0) { 　　
                                j--; 　　}// end while 　　
                if (i < j) { 　　
                 // 比枢纽元素小的移动到左边 　　
                  data[i] = data[j]; 　　i++; 　　
                }// end if 　
 　
                while (i < j && data[i].compareTo(pivotKey) < 0) { 　　
                             i++; 　　}// end while 　
　
                if (i < j) { 　　
                // 比枢纽元素大的移动到右边 　　
                 data[j] = data[i]; 　　j--; 　　
                 }// end if 　　}// end while 　　
 
                // 枢纽元素移动到正确位置 　　
                data[i] = pivotKey; 　　

               // 前半个子表递归排序 　　
                sort(data, low, i - 1); 　　

               // 后半个子表递归排序 　　
                sort(data, i + 1, high); 　　
              
                 }// end if 　　
               }// end sort 　　

      public static void main(String[] args) { 　　

             // 在JDK1.5版本以上,基本数据类型可以自动装箱 　　
             // int,double等基本类型的包装类已实现了Comparable接口 　　
             Comparable[] c = { 4, 9, 23, 1, 45, 27, 5, 2 }; 　　
              sort(c, 0, c.length - 1); 　　
             for (Comparable data : c) { 　　
                   System.out.println(data); 　　
              } 　　
             } 　　
           }
 

C
　　//参照《数据结构》（C语言版） 　　
    //调用：quicksort-->qsort-->partitions 　　
    int partitions(int a[],int low,int high) { 　　
       int pivotkey=a[low]; 　　

       //a[0]=a[low]; 　　
       while(low<high) { 　　
         while(low<high && a[high]>=pivotkey) 　　
                --high; 　　
         a[low]=a[high]; 　　
         while(low<high && a[low]<=pivotkey) 　　
                ++low; 　　
         a[high]=a[low]; 　
　
         } 　　
  
      //a[low]=a[0]; 　　
       a[low]=pivotkey; 　　
       return low; 　　} 　　

      void qsort(int a[],int low,int high) { 　　
          int pivottag; 　　
          if(low<high) { //递归调用 　　
               pivottag=partitions(a,low,high); 　　
               qsort(a,low,pivottag-1); 　　
               qsort(a,pivottag+1,high); 　　
           } 　　
          } 　　

      void quicksort(int a[],int n) { 　　
            qsort(a,0,n); 　　
       } 　　
 
      //简单示例 　　
      #include <stdio.h> 　　
      //#include <math.h> 　　
      #include "myfunc.h"  //存放于个人函数库中 　　
      main() { 　　
          int i,a[11]={0,11,12,5,6,13,8,9,14,7,10}; 　　
          for(i=0;i<11;printf("%3d",a[i]),++i); 　　
          printf("/n"); 　　
          quicksort(a,10); 　　
          for(i=0;i<11;printf("%3d",a[i]),++i); 　
          printf("/n"); 　　
      }