自:http://blog.csdn.net/duanml61/article/details/8264796

 

 算法,根据设计方法来分类,可以分为穷举法、分治法、线性规划法、动态规划法、贪心算法、回溯法等。


快速排序采用分治法,原理如下:

 

[plain] view plaincopy

  1. 快速排序是对冒泡排序的一种改进。它的基本思想是:通过一躺排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一不部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。  

  2.      假设要排序的数组是A[1]……A[N],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序。一躺快速排序的算法是:  

  3.     1)、设置两个变量I、J,排序开始的时候I:=1,J:=N;  

  4.     2)以第一个数组元素作为关键数据,赋值给X,即X:=A[1];  

  5.     3)、从J开始向前搜索,即由后开始向前搜索(J:=J-1),找到第一个小于X的值,两者交换;  

  6.     4)、从I开始向后搜索,即由前开始向后搜索(I:=I+1),找到第一个大于X的值,两者交换;  

  7.     5)、重复第3、4步,直到I=J;  

  8.     例如:待排序的数组A的值分别是:(初始关键数据X:=49)  

  9.                  A[1]      A[2]      A[3]      A[4]      A[5]       A[6]      A[7]:   

  10.                   49         38        65        97        76        13         27  

  11. 第一次交换后:    27         38        65        97        76        13         49  

  12. ( 按照算法的第三步从后面开始找)  

  13. 第二次交换后:    27         38        49        97        76        13         65  

  14. ( 按照算法的第四步从前面开始找>X的值,65>49,两者交换,此时I:=3 )  

  15. 第三次交换后:    27         38        13        97        76        49         65  

  16. ( 按照算法的第五步将又一次执行算法的第三步从后开始找)  

  17. 第四次交换后:    27         38        13        49        76        97         65  

  18. ( 按照算法的第四步从前面开始找大于X的值,97>49,两者交换,此时J:=4 )  

  19. 此时再执行第三步的时候就发现I=J,从而结束一躺快速排序,那么经过一躺快速排序之后的结果是:27    38    13    49    76    97    65,即所以大于49的数全部在49的后面,所以小于49的数全部在49的前面。  

  20.        快速排序就是递归调用此过程--再以49为中点分割这个数据序列,分别对前面一部分和后面一部分进行类似的快速排序,从而完成全部数据序列的快速排序,最后把此数据序列变成一个有序的序列。  

  21. 1)、设有N(假设N=10)个数,存放在S数组中;  

  22. 2)、在S[1。。N]中任取一个元素作为比较基准,例如取T=S[1],起目的就是在定出T应在排序结果中的位置K,这个K的位置在:S[1。。K-1]<=S[K]<=S[K+1..N],即在S[K]以前的数都小于S[K],在S[K]以后的数都大于S[K];  

  23. 3)、利用分治思想(即大化小的策略)可进一步对S[1...K-1]和S[K+1...N]两组数据再进行快速排序直到分组对象只有一个数据为止。  


文字太辛苦,看看图:

 

java分治法快速排序_java快速分治法排序


之前只是进行到这一步,真动手写代码,发现,弱爆了。


……………………


…………


还是写写吧,源码如下:

 

[java] view plaincopy

  1. package dec;  

  2.   

  3. /** 

  4.  *  

  5.  *  

  6.  * <p> 

  7.  * Title: 快速排序示例代码 /p> 

  8.  *  

  9.  * <p> 

  10.  * Description: 示例 业务类 

  11.  * </p> 

  12.  *  

  13.  * <p> 

  14.  * Copyright: Copyright (c) 2012 

  15.  * </p> 

  16.  *  

  17.  *  

  18.  * @author dml@2012-12-6 

  19.  * @version 1.0 

  20.  */  

  21.   

  22. public class QSort {  

  23.   

  24.     /** 

  25.      * @param args 

  26.      */  

  27.     public static void main(String[] args) {  

  28.         quicksort qs = new quicksort();  

  29.         int data[] = { 1423232543258793911 };  

  30.         qs.data = data;  

  31.         qs.sort(0, qs.data.length - 1);  

  32.         qs.display();  

  33.     }  

  34.   

  35. }  

  36.   

  37. class quicksort {  

  38.     public int data[];  

  39.   

  40.     private int partition(int sortArray[], int low, int high) {  

  41.         int key = sortArray[low];  

  42.   

  43.         while (low < high) {  

  44.             while (low < high && sortArray[high] >= key)  

  45.                 high--;  

  46.             sortArray[low] = sortArray[high];  

  47.   

  48.             while (low < high && sortArray[low] <= key)  

  49.                 low++;  

  50.             sortArray[high] = sortArray[low];  

  51.         }  

  52.         sortArray[low] = key;  

  53.         return low;  

  54.     }  

  55.   

  56.     public void sort(int low, int high) {  

  57.         if (low < high) {  

  58.             int result = partition(data, low, high);  

  59.             sort(low, result - 1);  

  60.             sort(result + 1, high);  

  61.         }  

  62.   

  63.     }  

  64.   

  65.     public void display() {  

  66.         for (int i = 0; i < data.length; i++) {  

  67.             System.out.print(data[i]);  

  68.             System.out.print(" ");  

  69.         }  

  70.     }  

  71. }  


要真这么写就提交了,肯定被骂死,按照步骤来,先写抽象类:

 

 

[java] view plaincopy

  1. package dec;  

  2.   

  3. /** 

  4.  *  

  5.  *  

  6.  * <p>Title: 快速排序 /p> 

  7.  * 

  8.  * <p>Description: 示例 业务类</p> 

  9.  * 

  10.  * <p>Copyright: Copyright (c) 2012</p> 

  11.  * 

  12.  * 

  13.  * @author dml@2012-12-6 

  14.  * @version 1.0 

  15.  */  

  16. public abstract class QuickSort {  

  17.     protected abstract int partition(int sortArray[], int low, int high);  

  18.     public abstract void sort(int low, int high);  

  19.     public abstract void display();  

  20. }  

既然是分治法,关键的方法就是怎么分,怎么处理,这个写清楚了,基本也就搞清楚这个算法的实现过程了。


实现类如下:

 

[java] view plaincopy

  1. package dec;  

  2.   

  3. /** 

  4.  *  

  5.  *  

  6.  * <p> 

  7.  * Title: 快速排序实现类 /p> 

  8.  *  

  9.  * <p> 

  10.  * Description: 示例 业务类 

  11.  * </p> 

  12.  *  

  13.  * <p> 

  14.  * Copyright: Copyright (c) 2012 

  15.  * </p> 

  16.  *  

  17.  *  

  18.  * @author dml@2012-12-6 

  19.  * @version 1.0 

  20.  */  

  21. public class QuickSortImpl extends QuickSort {  

  22.     public int data[];  

  23.   

  24.     /* 

  25.      * (non-Javadoc) 

  26.      *  

  27.      * @see dec.QuickSort#partition(int[], int, int) 

  28.      */  

  29.     @Override  

  30.     protected int partition(int[] sortArray, int low, int high) {  

  31.         int key = sortArray[low];  

  32.   

  33.         while (low < high) {  

  34.             while (low < high && sortArray[high] >= key)  

  35.                 high--;  

  36.             sortArray[low] = sortArray[high];  

  37.   

  38.             while (low < high && sortArray[low] <= key)  

  39.                 low++;  

  40.             sortArray[high] = sortArray[low];  

  41.         }  

  42.         sortArray[low] = key;  

  43.         return low;  

  44.     }  

  45.   

  46.     /* 

  47.      * (non-Javadoc) 

  48.      *  

  49.      * @see dec.QuickSort#sort(int, int) 

  50.      */  

  51.     @Override  

  52.     public void sort(int low, int high) {  

  53.         if (low < high) {  

  54.             int result = partition(data, low, high);  

  55.             sort(low, result - 1);  

  56.             sort(result + 1, high);  

  57.         }  

  58.     }  

  59.   

  60.     /* 

  61.      * (non-Javadoc) 

  62.      *  

  63.      * @see dec.QuickSort#display() 

  64.      */  

  65.     @Override  

  66.     public void display() {  

  67.         for (int i = 0; i < data.length; i++) {  

  68.             System.out.print(data[i]);  

  69.             System.out.print(" ");  

  70.         }  

  71.     }  

  72.   

  73.     public static void main(String[] args) {  

  74.         QuickSortImpl qs = new QuickSortImpl();  

  75.         int data[] = { 1423232543258793911 };  

  76.         qs.data = data;  

  77.         qs.sort(0, qs.data.length - 1);  

  78.         qs.display();  

  79.     }  

  80.   

  81. }

  82.  

  83.  

  84.  转自:http://blog.csdn.net/duanml61/article/details/8264796