六、内部排序综合（九种）—插入类排序（直接插入、折半插入、希尔排序）；交换类排序（冒泡、快速）；选择类排序（简单选择、堆排序）；二路归并排序；基数排序

冒泡排序：

设数组长度为N，

1、比较相邻前后两个数据，数组为[0，N-1]，则要比较N-1次

2、循环一次后，最大或者最小的数在数组最后面，这样比较数组[0，N-2]，重复上述步骤即可

综上其就是两个for循环

第一个for循环表示：要排序的数值个数-1

第二个for循环表示：将无序数组进行排序，即比较相邻的两个数值

以下为代码：

[cpp]  view plain copy

1. // sort.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5.   
6.   
7. void Swap(int &a, int &b)  
8. {  
9.    int temp = a;  
10.    a = b;  
11.    b = temp;  
12. }  
13.   
14. void BubbleSort1(int a[], int n)  
15. {  
16.     int i,j;  
17.   
18.     for (i = 0; i < n - 1; i++)  
19.     {  
20.         for (j = 0; j < n - i - 1; j++)  
21.         {  
22.             if (a[j] > a[j+1])  
23.             {  
24.                 Swap(a[j], a[j+1]);  
25.             }  
26.         }  
27.     }  
28.   
29.      for (int i = 0; i < n; i++)  
30.      {  
31.          printf("%d\t", a[i]);  
32.      }  
33. }  
34.   
35. //改进  
36. void BubbleSort2(int a[], int n)  
37. {  
38.     int i, j = n - 1;  
39.     bool flag = true;            //设置标志，如果这一趟发生交换，则为true，否则为false  
40.   
41.     while(flag)  
42.     {  
43.         flag = false;  
44.         for(i = 0; i < j; i++)  
45.             if (a[i] > a[i+1])  
46.             {  
47.                 Swap(a[i], a[i+1]);;  
48.                 flag = true;  
49.             }  
50.         j--;  
51.     }  
52.       
53.     for (int i = 0; i < n; i++)  
54.     {  
55.         printf("%d\t", a[i]);  
56.     }  
57. }  
58.   
59. int _tmain(int argc, _TCHAR* argv[])  
60. {  
61.     int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  
62.   
63.     BubbleSort2(score, 8);  
64.   
65.     return 0;  
66. }  

直接插入排序：

设数组为a[0，n-1]；

1、取i = 1,2......n-1，每设置一次i的值，即将数组a[0，i-1]进行排序。

2、这样a[0，n-1]可以分为两个部分，a[0，i-1]为排好序的，而a[i，n-1]为无序。

3、i++直到n-1，即1步骤，即可。

以下是代码：

[cpp]  view plain copy

1. void InsertSort1(int a[], int n)  
2. {  
3.     int i,j,k;  
4.     for (i = 1; i < n; i++)  //将下标1到n-1进行直接插入排序  
5.     {  
6.         for (j = i-1; j >=0; j--)  //当下标为i时，将a[i]排在a[0，i-1]上  
7.         {  
8.             if(a[j] < a[i])  
9.                 break;  
10.         }  
11.   
12.         if ( j != i-1 )          //如果j不在i的前一位，即表示将a[i]查到a[0，i-1]之间  
13.         {  
14.             int temp = a[i];  
15.             for(k = i - 1; k > j; k--)  
16.                 a[k+1]=a[k];  
17.             a[k+1] = temp;  
18.         }  
19.     }  
20. }  
21.   
22. //改进直接插入排序  
23. void Insertsort2(int a[], int n)  
24. {  
25.     int i,j;  
26.     for (i = 1; i < n; i++)  
27.         if (a[i] < a[i-1])  
28.         {  
29.             int temp = a[i];  
30.             for (j = i - 1; j >= 0 && a[j] > temp; j--)  
31.             {  
32.                 a[j+1] = a[j];  
33.             }  
34.             a[j+1] = temp;  
35.         }  
36.       
37.       
38. }  

希尔排序：

1、将无序数组分割成若干个子序列，子序列的长度（gap = n/2）是相隔特定的增量子序列，将各子序列进行直接插入排序；

2、在排序一次后，将数组再次分割若干子序列，子序列的长度（gap /= 2）是相隔特定的增量子序列，将各子序列进行直接插入排序；

3、重复上述过程，直到gap = 0时，数组排序完成。

以下为代码：

[cpp]  view plain copy

1. void shellSort1(int a[], int n)  
2. {  
3.     int i,j,gap; //gap为步长  
4.     for (gap = n/2; gap > 0; gap /= 2) // 设置步长  
5.         for (i = 0; i < gap; i++)      //按组排序  
6.         {  
7.             for (j = i + gap; j < n; j += gap)  
8.             {  
9.                 if (a[j] < a[j-gap])  //如果后面的比前面的小  
10.                 {  
11.                     int temp = a[j];  
12.                     int k = j-gap;  
13.   
14.                     while (k >= 0 && a[k] > temp)  
15.                     {  
16.                         a[k+gap] = a[k];  
17.                         k -= gap;  
18.                     }  
19.                     a[k+gap] = temp;  
20.                 }  
21.             }  
22.         }  
23.   
24. }  
25.   
26. //改进希尔排序  
27. void shellSort2(int a[], int n)  
28. {  
29.     int j,gap;  
30.     for(gap = n/2; gap > 0; gap /= 2)  
31.         for(j = gap; j < n; j++)   //从数组第gap个元素开始  
32.             if (a[j] < a[j-gap])  
33.             {  
34.                 int temp = a[j];  
35.                 int k = j-gap;  
36.   
37.                 while (k >= 0 && a[k] > temp)  
38.                 {  
39.                     a[k + gap] = a[k];  
40.                     k -= gap;  
41.                 }  
42.   
43.                 a[k+gap] = temp;  
44.             }  
45.   
46. }  

归并排序：

先分，在组合，这里是递归算法

代码如下：

[cpp]  view plain copy

1. void mergeArray(int a[], int first, int mid, int last, int temp[])  
2. {  
3.     int i = first, j = mid + 1, k = 0;  
4.     int m = mid, n = last;  
5.   
6.     while (i <= m && j <= n)  
7.     {  
8.         if(a[i] < a[j])  
9.             temp[k++] = a[i++];  
10.         else  
11.             temp[k++] = a[j++];  
12.     }  
13.   
14.     while(i <= m)  
15.         temp[k++] = a[i++];  
16.   
17.     while(j <= n)  
18.         temp[k++] = a[j++];  
19.   
20.     for (i = 0; i < k; i++)  
21.     {  
22.         a[first + i] = temp[i];  
23.   
24.     }  
25. }  
26.   
27.   
28. void mergesort(int a[], int first, int last, int temp[])  
29. {  
30.     if (first < last)  
31.     {  
32.         int mid = (first + last)/2;  
33.         mergesort(a, first, mid, temp);  
34.         mergesort(a, mid + 1, last, temp);  
35.         mergeArray(a, first, mid, last, temp);  
36.     }  
37. }  
38.   
39. bool MergeSort(int a[], int n)  
40. {  
41.     int* pTempArray = new int[n];  
42.     if(pTempArray == NULL)  
43.         return false;  
44.     mergesort(a, 0, n-1, pTempArray);  
45.     delete[] pTempArray;  
46.     return true;  
47.   
48.   
49. }  

快速排序：

1、在数组取一个数作为基数

2、在L在往前查找比基数小的数，然后将此坑与基数的坑对换。

3、在R往后查找比基数大的数，然后将此坑与基数的坑对换。

4、知道LR相等时，将基数放置在L或者R处。

以下为代码：

[cpp]  view plain copy

1. void quickSort(int a[], int L, int R)  
2. {  
3.     if( L < R )  
4.     {  
5.         int i = L, j = R, x = a[L];  
6.   
7.         while (i < j)  
8.         {  
9.             while ( i < j && a[j] >= x)  
10.                j--;  
11.             if(i < j)  
12.                 a[i++] = a[j];  
13.   
14.             while (i < j && a[i] < x)  
15.                 i++;  
16.             if(i < j)  
17.                 a[j--] = a[i];    
18.               
19.         }  
20.         a[i] = x;  
21.         quickSort(a, L, i-1);  
22.         quickSort(a,i+1, R);  
23.     }  
24. }  

---------------------------------------------------------------------------

java实现：

[java]  view plain copy

1. package com.example.sorts;  
2.   
3. public class sorts {  
4.       
5.     //冒泡排序  
6.     public static void bubbleSort(int[] arr){  
7.         int i, j;  
8.         int len = arr.length;  
9.         int temp;  
10.         for(i = 0; i < len - 1; i++)  
11.             for(j = 0; j < len - 1 - i; j++){  
12.                 if(arr[j] > arr[j+1]){  
13.                     temp = arr[j];  
14.                     arr[j] = arr[j+1];  
15.                     arr[j+1] = temp;  
16.                 }  
17.             }  
18.     }  
19.       
20.     //直接插入排序  
21.     public static void insertSort(int[] arr){  
22.         int i, j;  
23.         int len = arr.length;  
24.         int temp;  
25.         for(i = 1; i < len; i++)  
26.             if(arr[i] < arr[i-1]){  
27.                 temp = arr[i];  
28.                 for(j = i - 1; j >= 0 && arr[j] > temp; j--)  
29.                     arr[j+1] = arr[j];  
30.                 arr[j+1] = temp;      
31.             }  
32.     }  
33.       
34.     //希尔排序  
35.     public static void shellSort(int[] arr){  
36.         int i, j;  
37.         int gap; //间隔  
38.         int len = arr.length;  
39.         int temp;  
40.         for(gap = len/2; gap > 0; gap /= 2)  
41.             for(i = gap; i < len; i++)  
42.                 if(arr[i] < arr[i-gap]){  
43.                     temp = arr[i];  
44.                     for(j = i - gap; j >= 0 && arr[j] > temp; j -= gap)  
45.                         arr[j+gap] = arr[j];  
46.                     arr[j+gap] = temp;  
47.                 }  
48.     }  
49.       
50.     //直接选择排序  
51.     public static void selectSort(int[] arr){  
52.         int i, j;  
53.         int len = arr.length;  
54.         int temp;  
55.         int nMinIndex;  
56.         for(i = 0; i < len; i++){  
57.             nMinIndex = i;  
58.             for(j = i + 1 ; j < len ; j++)  
59.                 if(arr[nMinIndex] > arr[j])  
60.                     nMinIndex = j;  
61.             temp = arr[nMinIndex];  
62.             arr[nMinIndex] = arr[i];  
63.             arr[i] = temp;  
64.         }  
65.     }  
66.       
67.       
68.     //归并排序  
69.     public static void mergeSort(int[] arr, int low, int high){  
70.         int mid = (low + high)/2;  
71.         if(low < high){  
72.         mergeSort(arr, low, mid);  
73.         mergeSort(arr, mid+1, high);  
74.         merge(arr, low, mid, high);  
75.         }  
76.     }  
77.       
78.     public static void merge(int[] arr, int low, int mid, int high){  
79.         int[] temp = new int[high-low+1];  
80.         int i = low;  //数组1的起始点  
81.         int j = mid+1; //数组2的起始点  
82.         int k = 0;  
83.           
84.         while(i <= mid && j <= high){  
85.             if(arr[i] < arr[j]){  
86.                 temp[k++] = arr[i++];  
87.             }else{  
88.                 temp[k++] = arr[j++];  
89.             }  
90.         }  
91.           
92.         while(i <= mid){  
93.             temp[k++] = arr[i++];  
94.         }  
95.           
96.         while(j <= high){  
97.             temp[k++] = arr[j++];  
98.         }  
99.           
100.         for(int m = 0; m < temp.length; m++)  
101.             arr[low+m] = temp[m];  
102.     }  
103.       
104.     //快速排序  
105.     public static void quickSort(int[] arr, int L, int R){  
106.         if(L < R){  
107.             int i = L, j = R;  
108.             //选定基数  
109.             int x = arr[i];  
110.             while(i < j){  
111.                   
112.                 while(i < j && arr[j] >= x)  
113.                     j--;  
114.                 if(i < j)  
115.                     arr[i++] = arr[j];  
116.                   
117.                 while(i < j && arr[i] < x)  
118.                     i++;  
119.                 if(i < j)  
120.                     arr[j--] = arr[i];    
121.             }  
122.             arr[i] = x;  
123.             quickSort(arr, L, i-1);  
124.             quickSort(arr, i+1, R);  
125.         }  
126.     }  
127.       
128.     //堆排序  
129.       
130.     public static void MinHeapSort(int[] arr, int n){  
131.         int temp;  
132.         //建立最小堆  
133.         MakeMinHeap(arr, n);  
134.         for(int i = n - 1; i >= 0; i--){  
135.             temp = arr[i];  
136.             arr[i] = arr[0];  
137.             arr[0] = temp;  
138.             MinHeapFixdown(arr, 0, i);  
139.         }  
140.     }  
141.       
142.     public static void MinHeapFixdown(int[] arr, int i, int n){  //i表示节点，n表示节点数  
143.         int j; //子节点  
144.         int temp = arr[i];//将父节点值保存到temp  
145.         j = 2*i + 1;  
146.           
147.         while(j < n){  
148.             if(j + 1 < n && arr[j+1] < arr[j])  
149.                 j++;  
150.             if(temp <= arr[j])  
151.                 break;  
152.             arr[i] = arr[j];  
153.             i = j;    //将子节点设置为父节点  
154.             j = 2*i + 1; //得到父节点的子节点  
155.         }  
156.         arr[i] = temp;  
157.     }  
158.     //建立最小堆  
159.     public static void MakeMinHeap(int[] arr, int n){  
160.         for(int i = n/2 - 1; i >= 0; i--)  
161.             MinHeapFixdown(arr, i, n);  
162.     }  
163.       
164.     public static void main(String[] args){  
165.   
166.         int[] arrI = {9, 12, 17, 30, 50, 20, 60, 65, 4, 49};  
167.         MinHeapSort(arrI, 10);  
168.           
169.         for(int k : arrI)  
170.             System.out.print(k+" ");  
171.     }  
172.   
173. }