快速排序算法

快速排序（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 　　( 按照算法的第三步从后面开始找)　　进行第二次交换后： 2738 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 3813 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"); 　　
      }