排序算法二（归并排序快速排序希尔排序）

Posted 2021-04-25 程序猿技术大咖

一、归并排序：（MergeSort）

       将数组分成两半，先对每一半分别排序，然后把有序的两半归并（merge）为一个有序的数组。

如：【38,16,27,39,12,27】

Java代码：

[java] view plain copy

1. package 排序算法;  

2.   

3. import java.util.Arrays;  

4.   

5. /** 

6.  * 归并排序 

7.  * @author xcbeyond 

8.  * @date 2012-6-21 上午11:33:15 

9.  */  

10. public class mergeSort {  

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

12.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;  

13.         mergeSort(a,0,a.length-1);  

14.           

15.         System.out.println(Arrays.toString(a));  

16.     }  

17.     /** 

18.      * 归并排序 

19.      * @param array 

20.      * @param first 数组起始下标 

21.      * @param last 数组末尾下标 

22.      */  

23.     public static void mergeSort(int[] array,int first,int last) {  

24.         if(first<last) {  

25.             int mid = (first+last)/2;  

26.             mergeSort(array,first,mid);  

27.             mergeSort(array,mid+1,last);  

28.             merge(array,first,mid,last);  

29.         }  

30.     }  

31.     private static void merge(int[] array, int first, int mid, int last) {  

32.         int[] tempArray = new int[array.length];  

33.         int first1 = first;  

34.         int last1 = mid;  

35.         int first2 = mid + 1;  

36.         int last2 = last;  

37.           

38.         int index  = first;  

39.           

40.         while((first1<=last1) && (first2 <= last2)) {  

41.             if(array[first1]<array[first2]) {  

42.                 tempArray[index] = array[first1];  

43.                 first1 ++ ;  

44.             }  

45.             else {  

46.                 tempArray[index] = array[first2];  

47.                 first2 ++ ;  

48.             }  

49.             index++;  

50.         }  

51.           

52.         while(first1<=last1) {  

53.             tempArray[index] = array[first1];  

54.             first1++;  

55.             index++;  

56.         }  

57.         while(first2<=last2) {  

58.             tempArray[index] = array[first2];  

59.             first2++;  

60.             index++;  

61.         }  

62.           

63.         for (index = first; index <= last; index++) {  

64.             array[index] = tempArray[index];  

65.         }  

66.           

67.     }  

68.       

69. }  

 

二、快速排序：（quickSort）

      在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。
   排序过程：
       初始关键字 ［49 38 65 97 76 13 27 49］
       一趟排序之后 ［27 38 13］ 49 ［76 97 65 49］
       二趟排序之后 ［13］ 27 ［38］ 49 ［49 65］76 ［97］
       三趟排序之后 13 27 38 49 49 ［65］76 97
       最后的排序结果 13 27 38 49 49 65 76 97

 

程序代码：

 

[java] view plain copy

1. package 排序算法;  

2.   

3. import java.util.Arrays;  

4.   

5. public class QuickSort {  

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

7.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;  

8.         quickSort(a,0,a.length-1);  

9.           

10.         System.out.println(Arrays.toString(a));  

11.     }  

12.     /** 

13.      * 快速排序 

14.      * @param array 

15.      * @param first 

16.      * @param last 

17.      */  

18.     public static void quickSort(int[] array,int first,int last) {  

19.         int pIndex ;  

20.         if(first<last) {  

21.             pIndex = partition(array,first,last);//“基准”值位置  

22.               

23.             quickSort(array,first,pIndex-1);  

24.             quickSort(array,pIndex+1,last);  

25.         }  

26.     }  

27.     /** 

28.      * 一次划分，找到基准的位置 

29.      * @param array 

30.      * @param first 

31.      * @param last 

32.      * @return  基准的位置 

33.      */  

34.     private static int partition(int[] array,int first,int last) {  

35.         int p =array[first];  

36.           

37.         while(first<last) {  

38.             while(first<last && array[last]>=p)  

39.                 last--;  

40.             array[first] = array[last];  

41.               

42.             while(first<last && array[first]<=p)  

43.                 first++;  

44.             array[last] = array[first];  

45.         }  

46.         array[first] = p;  

47.         return first;  

48.     }  

49.       

50. }  

 

三、希尔排序：（shellSort）

      先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

排序过程：

   待排序序列：39，80，76，41，13，29，50，78，30，11，100，7，41，86

   取步长d分别为5，3，1

d=5   39，80，76，41，13，29，50，78，30，11，100，7，41，86

            |-------------------------------|-----------------------------|

                    |------------------------------|------------------------------|

                            |-----------------------------|------------------------------|

                                     |----------------------------|------------------------------|

                                              |-------------------------------|

各自序列分别为：｛39，29，100｝｛80，50，7｝｛76，78，41｝｛41，30，86｝｛13，11｝

对每个自序列进行直接插入排序，顺序调入各个自序列对应排序元素，得到第一趟排序结果：

d=3    29，7，41，30，11，39，50，76，41，13，100，80，78，86

             |-----------------|-----------------|-----------------|------------------|

                     |----------------|------------------|-----------------|------------------|

                            |------------------|-----------------|-------------------|

各自序列分别为：｛29，30，50，13，78｝｛7，11，76，100，86｝｛41，39，41，80｝。对每个自序列进行直接插入排序，顺序调入各个自序列对应排序元素，得到第二趟排序结果：

d=1   13，7，39，29，11，41，30，76，41，50，86，80，78，100

此时，序列基本“有序”，对其直接进行插入排序，得到最终结果：

7，11，13，29，30，39，41，41，50，76，78，80，86，100

 

Java程序代码：

[java] view plain copy

1. package 排序算法;  

2.   

3. import java.util.Arrays;  

4.   

5. /** 

6.  * 希尔排序：有步长的直接插入排序 

7.  * @author xcbeyond 

8.  * @date 2012-7-8 上午11:27:32 

9.  */  

10. public class ShellSort {  

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

12.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;  

13.         shellSort(a);  

14.           

15.         System.out.println(Arrays.toString(a));  

16.     }  

17.       

18.     public static void shellSort(int[] array){  

19.         int temp;   

20.         int d =array.length;//步长  

21.         while(true){   

22.             d= d/2;   

23.           

24.             for(int i=0;i<d;i++){   

25.                 for(int j=i+d;j<array.length;j+=d){   

26.                     int k=j-d;   

27.                     temp=array[j];   

28.                     for(;k>=0&&temp<array[k];k-=d){   

29.                         array[k+d]=array[k];   

30.                     }   

31.                     array[k+d]=temp;   

32.                 }   

33.             }   

34.         if(d==1)   

35.             break;   

36.   

37.         }  

38.     }  

39. }  

40.