常用排序算法

（1）直接插入排序

[java] view plain copy

1. /** 直接插入排序 **/  
2. /** 数组是引用类型，元素值将被改变 **/  
3. public static void insertSort(int[] table) {  
4.     /** n-1趟扫描 **/  
5.     for (int i = 1; i < table.length; i++) {  
6.         /** 每趟将table[i]插入到前面已排序的序列中 **/  
7.         int temp = table[i], j;  
8.         /** 将前面较大元素向后移动 **/  
9.         for (j = i - 1; j > -1 && temp < table[j]; j--) {  
10.             table[j + 1] = table[j];  
11.         }  
12.         /** temp值到达插入位置 **/  
13.         table[j + 1] = temp;  
14.     }  
15. }  

（2）希尔排序

[java] view plain copy

1. /** 希尔排序 **/  
2.     public static void shellSort(int[] table) {  
3.         /** 控制增量，增量减半，若干趟扫描 **/  
4.         for (int delta = table.length / 2; delta > 0; delta /= 2) {  
5.             /** 一趟中若干组，每个元素在自己所属组内进行直接插入排序 **/  
6.             for (int i = delta; i < table.length; i++) {  
7.                 /** 当前待插入元素 **/  
8.                 int temp = table[i];  
9.                 /** 相距delta远 **/  
10.                 int j = i - delta;  
11.                 /** 一组中前面较大的元素向后移动 **/  
12.                 /** 继续与前面的元素比较 **/  
13.                 while (j >= 0 && temp < table[j]) {  
14.                     table[j + delta] = table[j];  
15.                     j -= delta;  
16.                 }  
17.                 /** 插入元素位置 **/  
18.                 table[j + delta] = temp;  
19.             }  
20.         }  
21.     }  

（3）冒泡排序

[java] view plain copy

1. /** 冒泡排序 **/  
2.     public static void bubbleSort(int[] table) {  
3.         /** 是否交换的标记 **/  
4.         boolean exchange = true;  
5.         /** 有交换时再进行下一趟，最多n-1趟 **/  
6.         for (int i = 1; i < table.length && exchange; i++) {  
7.             /** 假定元素未交换 **/  
8.             exchange = false;  
9.             /** 一次比较、交换 **/  
10.             for (int j = 0; j < table.length - i; j++) {  
11.                 /** 反序时，交换 **/  
12.                 if (table[j] > table[j + 1]) {  
13.                     int temp = table[j];  
14.                     table[j] = table[j + 1];  
15.                     table[j + 1] = temp;  
16.                     /** 有交换 **/  
17.                     exchange = true;  
18.                 }  
19.             }  
20.         }  
21.     }  

（4）快速排序

[java] view plain copy

1. /** 快速排序 **/  
2.     public static void quickSort(int[] table) {  
3.         quickSort(table, 0, table.length - 1);  
4.     }  
5.   
6.     /** 一趟快速排序，递归算法 **/  
7.     private static void quickSort(int[] table, int low, int high) { // low、high指定序列的下界和上界  
8.         /** 序列有效 **/  
9.         if (low < high) {  
10.             int i = low, j = high;  
11.             /** 第一个值作为基准值 **/  
12.             int vot = table[i];  
13.             /** 一趟排序 **/  
14.             while (i != j) {  
15.                 /** 从后向前寻找较小值 **/  
16.                 while (i < j && vot <= table[j])  
17.                     j--;  
18.                 if (i < j) {  
19.                     /** 较小元素向前移动 **/  
20.                     table[i] = table[j];  
21.                     i++;  
22.                 }  
23.                 /** 从前向后寻找较大值 **/  
24.                 while (i < j && table[i] < vot)  
25.                     i++;  
26.                 if (i < j) {  
27.                     /** 较大元素向后移动 **/  
28.                     table[j] = table[i];  
29.                     j--;  
30.                 }  
31.             }  
32.             /** 基准值的最终位置 **/  
33.             table[i] = vot;  
34.             /** 前端子序列再排序 **/  
35.             quickSort(table, low, j - 1);  
36.             /** 后端子序列再排序 **/  
37.             quickSort(table, i + 1, high);  
38.         }  
39.     }  

（5）直接选择排序

[java] view plain copy

1. /** 直接选择排序 **/  
2.     public static void selectSort(int[] table) {  
3.         /** n-1趟排序 **/  
4.         for (int i = 0; i < table.length - 1; i++) {  
5.             /** 每趟在从table[i]开始的子序列中寻找最小元素 **/  
6.             /** 设第i个数据元素最小 **/  
7.             int min = i;  
8.             /** 在子序列中查找最小值 **/  
9.             for (int j = i + 1; j < table.length; j++)  
10.                 if (table[j] < table[min])  
11.                     /** 记住最小元素下标 **/  
12.                     min = j;  
13.             /** 将本趟最小元素交换到前边 **/  
14.             if (min != i) {  
15.                 int temp = table[i];  
16.                 table[i] = table[min];  
17.                 table[min] = temp;  
18.             }  
19.         }  
20.     }  

（6）堆排序

[java] view plain copy

1. /** 堆排序 **/  
2.     public static void heapSort(int[] table) {  
3.         int n = table.length;  
4.         /** 创建最小堆 **/  
5.         for (int j = n / 2 - 1; j >= 0; j--)  
6.             sift(table, j, n - 1);  
7.         /** 每趟将最小值交换到后面，再调整成堆 **/  
8.         for (int j = n - 1; j > 0; j--) {  
9.             int temp = table[0];  
10.             table[0] = table[j];  
11.             table[j] = temp;  
12.             sift(table, 0, j - 1);  
13.         }  
14.     }  
15.   
16.     /** 将以low为根的子树调整成最小堆 **/  
17.     private static void sift(int[] table, int low, int high) {  
18.         /** low、high是序列下界和上界 **/  
19.         /** 子树的根 **/  
20.         int i = low;  
21.         /** j为i结点的左孩子 **/  
22.         int j = 2 * i + 1;  
23.         /** 获得第i个元素的值 **/  
24.         int temp = table[i];  
25.         /** 沿较小值孩子结点向下筛选 **/  
26.         while (j <= high) {  
27.             /** 数组元素比较（改成<为最大堆） **/  
28.             if (j < high && table[j] > table[j + 1])  
29.                 /** j为左右孩子的较小者 **/  
30.                 j++;  
31.             /** 若父母结点值较大（改成<为最大堆） **/  
32.             if (temp > table[j]) {  
33.                 /** 孩子结点中的较小值上移 **/  
34.                 table[i] = table[j];  
35.                 /** i、j向下一层 **/  
36.                 i = j;  
37.                 j = 2 * i + 1;  
38.             } else  
39.                 j = high + 1;  
40.         }  
41.         /** 当前子树的原根值调整后的位置 **/  
42.         table[i] = temp;  
43.     }  

（7）归并排序

[java] view plain copy

1. /** 归并排序 **/  
2.     public static void mergeSort(int[] X) {  
3.         /** 已排序的子序列长度，初值为1 **/  
4.         int n = 1;  
5.         /** Y数组长度同X数组 **/  
6.         int[] Y = new int[X.length];  
7.         do {  
8.             /** 一趟归并，将X数组中各子序列归并到Y中 **/  
9.             mergepass(X, Y, n);  
10.             /** 子序列长度加倍 **/  
11.             n *= 2;  
12.   
13.             if (n < X.length) {  
14.                 /** 将Y数组中各子序列再归并到X中 **/  
15.                 mergepass(Y, X, n);  
16.                 n *= 2;  
17.             }  
18.         } while (n < X.length);  
19.     }  
20.   
21.     /** 一趟归并 **/  
22.     private static void mergepass(int[] X, int[] Y, int n) {  
23.         int i = 0;  
24.         while (i < X.length - 2 * n + 1) {  
25.             merge(X, Y, i, i + n, n);  
26.             i += 2 * n;  
27.         }  
28.         if (i + n < X.length)  
29.             /** 再一次归并 **/  
30.             merge(X, Y, i, i + n, n);  
31.         else  
32.             /** 将X剩余元素复制到Y中 **/  
33.             for (int j = i; j < X.length; j++)  
34.                 Y[j] = X[j];  
35.     }  
36.   
37.     /** 一次归并 **/  
38.     private static void merge(int[] X, int[] Y, int m, int r, int n) {  
39.         int i = m, j = r, k = m;  
40.         /** 将X中两个相邻子序列归并到Y中 **/  
41.         while (i < r && j < r + n && j < X.length)  
42.             /** 较小值复制到Y中 **/  
43.             if (X[i] < X[j])  
44.                 Y[k++] = X[i++];  
45.             else  
46.                 Y[k++] = X[j++];  
47.         /** 将前一个子序列剩余元素复制到Y中 **/  
48.         while (i < r)  
49.             Y[k++] = X[i++];  
50.         /** 将后一个子序列剩余元素复制到Y中 **/  
51.         while (j < r + n && j < X.length)  
52.             Y[k++] = X[j++];  
53.     }  

转载于:https://www.cnblogs.com/dailidong/p/7571143.html