各种排序总结（二）之--归并排序、希尔排序、插入排序

 1.  归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。 　　

           A: 如设有数列{6，202，100，301，38，8，1} 　　

           B: 初始状态： [6] [202] [100] [301] [38] [8] [1] 比较次数 　　

           C: i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ]　3 　　

           D: i=2 [ 6 100 202 301 ] [ 1 8 38 ]　4 　　

           E: i=3　[ 1 6 8 38 100 202 301 ] 4

   代码如下：

[java]  view plain  copy

1. <span style="font-size:18px;">package lianxi_01;  
2.   
3. import java.util.Arrays;  
4.   
5.   
6. public class MergeDemo {  
7.     //初始化  
8.     public static void sort(int[] data) {  
9.         int[] temp = new int[data.length];  
10.         mergeSort(data, temp, 0, data.length - 1);  
11.     }  
12.     //算法  
13.     private static void mergeSort(int[] data, int[] temp, int l, int r) {  
14.         int mid = (l + r) / 2;  
15.         if (l == r)  
16.             return;  
17.         mergeSort(data, temp, l, mid);  
18.         mergeSort(data, temp, mid + 1, r);  
19.   
20.         for (int i = l; i <= r; i++) {  
21.             temp[i] = data[i];  
22.         }  
23.         int i1 = l;  
24.         int i2 = mid + 1;  
25.         for (int cur = l; cur <= r; cur++) {  
26.             if (i1 == mid + 1)  
27.                 data[cur] = temp[i2++];  
28.             else if (i2 > r)  
29.                 data[cur] = temp[i1++];  
30.             else if (temp[i1] < temp[i2])  
31.                 data[cur] = temp[i1++];  
32.             else  
33.   
34.                 data[cur] = temp[i2++];  
35.         }  
36.     }  
37.       
38.     //交换数组中的两个元素  
39.     public static void swap(int[] data, int i, int j) {  
40.         int temp = data[i];  
41.         data[i] = data[j];  
42.         data[j] = temp;  
43.     }  
44.     //测试  
45.     public static void main(String[] args) {  
46.         int[] arr = { 6,202,100,301,38,8,1};  
47.          sort(arr);  
48.          System.out.println("排序后：" + Arrays.toString(arr));  
49.     }  
50. }  
51. </span>  

 2. 希尔排序属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 。　　

   排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，    重复上述分组和排序操作；直至di=1， 即所有记录放进一个组中排序为止 　　

  

  初始：d=5 　　49 38 65 97 76 13 27 49 55 04 　　

    49 13 　　|-------------------|　　

    38 27    |-------------------| 　　

    65 49 　　|-------------------|　　

    97 55    |-------------------| 　　

    76 04 　　|-------------------|　　

 

   一趟结果 　　13 27 49 55 04 49 38 65 97 76 　　

    d=3 　　 13 2749  55 04 49 38 65 97 76 　　

    13 55 38 76 |------------|------------|------------|　　

    27 04 65 |------------|------------| 　　

    49 49 97 |------------|------------| 　　

 

   二趟结果  13 04 49* 38 2749 55 65 97 76 　　

    d=1 　　13 04 49 3827 49 55 65 97 76

  　  　|----|----|----|----|----|----|----|----|----| 　　 三趟

 

  结果 　　

    04 13 27 38 49 49 55 65 76 97

代码如下：

[java]  view plain  copy

1. <span style="font-size:18px;">package lianxi_01;  
2.   
3. import java.util.Arrays;  
4.   
5.   
6. /* 
7.  * 希尔排序：先取一个小于n的整数d1作为第一个增量， 
8.  * 把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。 
9.  * 先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序， 
10.  * 直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。  
11.  */  
12. public class shellSort {  
13.     public static void sort(int[] data) {  
14.         for (int i = data.length / 2; i > 2; i /= 2) {  
15.             for (int j = 0; j < i; j++) {  
16.                 insertSort(data, j, i);  
17.             }  
18.         }  
19.         insertSort(data, 0, 1);  
20.     }  
21.       
22.     private static void insertSort(int[] data, int start, int inc) {  
23.         for (int i = start + inc; i < data.length; i += inc) {  
24.             for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {  
25.                 swap(data, j, j - inc);  
26.             }  
27.         }  
28.     }  
29.       
30.     public static void swap(int[] data, int i, int j) {  
31.         int temp = data[i];  
32.         data[i] = data[j];  
33.         data[j] = temp;  
34.     }  
35.       
36.     public static void main(String[] args) {  
37.         int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49, 55, 4 };  
38.         sort(arr);  
39.         System.out.println("排序后：" + Arrays.toString(arr));  
40.     }  
41. }  
42. </span>  

  3. 插入排序基本思想

    将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例下所示： 　　

    {{a1}，{a2，a3，a4，…，an}} 　　

    {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}}　

   {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　

    每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，

    找出插入位置，将该元素插入到有序数列的合适位置中。

代码如下：

[java]  view plain  copy

1. <span style="font-size:18px;">package lianxi_01;  
2.   
3. import java.util.Arrays;  
4.   
5. public class InsertSort {  
6.       
7.     public static void sort(int[] data) {  
8.         for (int i = 1; i < data.length; i++) {  
9.             for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {  
10.                 swap(data, j, j - 1);  
11.             }  
12.         }  
13.   
14.     }  
15.       
16.     public static void swap(int[] data, int i, int j) {  
17.         int temp = data[i];  
18.         data[i] = data[j];  
19.         data[j] = temp;  
20.     }  
21.       
22.     public static void main(String[] args) {  
23.         int[] arr = { 49, 38, 65, 97, 76, 13, 27, 49, 55, 4 ,34,101,87,63,111};  
24.         sort(arr);  
25.         System.out.println("排序后：" + Arrays.toString(arr));  
26.     }  
27. }  
28. </span>