分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序\
不稳定：快速排序，希尔排序，堆排序。
**
**
// 排序原始数据
private static final int[] NUMBERS =
{49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
1. 直接插入排序\
基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。
\
\
1 public static void insertSort(int[] array) {
2 for (int i = 1; i < array.length; i++) {
3 int temp = array[i];
4 int j = i - 1;
5 for (; j >= 0 && array[j] > temp; j--) {
6 //将大于temp的值整体后移一个单位
7 array[j + 1] = array[j];
8 }
9 array[j + 1] = temp;
10 }
11 System.out.println(Arrays.toString(array) + " insertSort");
12 }
2 . 希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
先取一个正整数d1 < n, 把所有相隔d1的记录放一组，每个组内进行直接插入排序；然后d2 < d1，重复上述分组和排序操作；直至di = 1，即所有记录放进一个组中排序为止。
\
\
\
1 public static void shellSort(int[] array) {
2 int i;
3 int j;
4 int temp;
5 int gap = 1;
6 int len = array.length;
7 while (gap < len / 3) { gap = gap * 3 + 1; }
8 for (; gap > 0; gap /= 3) {
9 for (i = gap; i < len; i++) {
10 temp = array[i];
11 for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
12 array[j + gap] = array[j];
13 }
14 array[j + gap] = temp;
15 }
16 }
17 System.out.println(Arrays.toString(array) + " shellSort");
18 }
3 . 简单选择排序
基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
\
\
1 public static void selectSort(int[] array) {
2 int position = 0;
3 for (int i = 0; i < array.length; i++) {
4 int j = i + 1;
5 position = i;
6 int temp = array[i];
7 for (; j < array.length; j++) {
8 if (array[j] < temp) {
9 temp = array[j];
10 position = j;
11 }
12 }
13 array[position] = array[i];
14 array[i] = temp;
15 }
16 System.out.println(Arrays.toString(array) + " selectSort");
17 }
4 . 堆排序
基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
\
建堆：
\
交换，从堆中踢出最大数
\
剩余结点再建堆，再交换踢出最大数
\
依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。
1 public static void heapSort(int[] array) {
2 /*
3 * 第一步：将数组堆化
4 * beginIndex = 第一个非叶子节点。
5 * 从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
6 * 叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
7 */
8 int len = array.length - 1;
9 int beginIndex = (len - 1) >> 1;
10 for (int i = beginIndex; i >= 0; i--) {
11 maxHeapify(i, len, array);
12 }
13 /*
14 * 第二步：对堆化数据排序
15 * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
16 * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
17 * 直至未排序的堆长度为 0。
18 */
19 for (int i = len; i > 0; i--) {
20 swap(0, i, array);
21 maxHeapify(0, i - 1, array);
22 }
23 System.out.println(Arrays.toString(array) + " heapSort");
24 }
25 private static void swap(int i, int j, int[] arr) {
26 int temp = arr[i];
27 arr[i] = arr[j];
28 arr[j] = temp;
29 }
30 /**
31 * 调整索引为 index 处的数据，使其符合堆的特性。
32 *
33 * @param index 需要堆化处理的数据的索引
34 * @param len 未排序的堆（数组）的长度
35 */
36 private static void maxHeapify(int index, int len, int[] arr) {
37 int li = (index << 1) + 1; // 左子节点索引
38 int ri = li + 1; // 右子节点索引
39 int cMax = li; // 子节点值最大索引，默认左子节点。
40 if (li > len) {
41 return; // 左子节点索引超出计算范围，直接返回。
42 }
43 if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。
44 { cMax = ri; }
45 if (arr[cMax] > arr[index]) {
46 swap(cMax, index, arr); // 如果父节点被子节点调换，
47 maxHeapify(cMax, len, arr); // 则需要继续判断换下后的父节点是否符合堆的特性。
48 }
49 }
5 . 冒泡排序
基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
\
1 public static void bubbleSort(int[] array) {
2 int temp = 0;
3 for (int i = 0; i < array.length - 1; i++) {
4 for (int j = 0; j < array.length - 1 - i; j++) {
5 if (array[j] > array[j + 1]) {
6 temp = array[j];
7 array[j] = array[j + 1];
8 array[j + 1] = temp;
9 }
10 }
11 }
12 System.out.println(Arrays.toString(array) + " bubbleSort");
13 }
6. 快速排序
基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
\
1 public static void quickSort(int[] array) {
2 _quickSort(array, 0, array.length - 1);
3 System.out.println(Arrays.toString(array) + " quickSort");
4 }
5
6
7 private static int getMiddle(int[] list, int low, int high) {
8 int tmp = list[low]; //数组的第一个作为中轴
9 while (low < high) {
10 while (low < high && list[high] >= tmp) {
11 high--;
12 }
13
14
15 list[low] = list[high]; //比中轴小的记录移到低端
16 while (low < high && list[low] <= tmp) {
17 low++;
18 }
19
20
21 list[high] = list[low]; //比中轴大的记录移到高端
22 }
23 list[low] = tmp; //中轴记录到尾
24 return low; //返回中轴的位置
25 }
26
27
28 private static void _quickSort(int[] list, int low, int high) {
29 if (low < high) {
30 int middle = getMiddle(list, low, high); //将list数组进行一分为二
31 _quickSort(list, low, middle - 1); //对低字表进行递归排序
32 _quickSort(list, middle + 1, high); //对高字表进行递归排序
33 }
34 }
7、归并排序
基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
\
1 public static void mergingSort(int[] array) {
2 sort(array, 0, array.length - 1);
3 System.out.println(Arrays.toString(array) + " mergingSort");
4 }
5
6 private static void sort(int[] data, int left, int right) {
7 if (left < right) {
8 //找出中间索引
9 int center = (left + right) / 2;
10 //对左边数组进行递归
11 sort(data, left, center);
12 //对右边数组进行递归
13 sort(data, center + 1, right);
14 //合并
15 merge(data, left, center, right);
16 }
17 }
18
19 private static void merge(int[] data, int left, int center, int right) {
20 int[] tmpArr = new int[data.length];
21 int mid = center + 1;
22 //third记录中间数组的索引
23 int third = left;
24 int tmp = left;
25 while (left <= center && mid <= right) {
26 //从两个数组中取出最小的放入中间数组
27 if (data[left] <= data[mid]) {
28 tmpArr[third++] = data[left++];
29 } else {
30 tmpArr[third++] = data[mid++];
31 }
32 }
33
34 //剩余部分依次放入中间数组
35 while (mid <= right) {
36 tmpArr[third++] = data[mid++];
37 }
38
39 while (left <= center) {
40 tmpArr[third++] = data[left++];
41 }
42
43 //将中间数组中的内容复制回原数组
44 while (tmp <= right) {
45 data[tmp] = tmpArr[tmp++];
46 }
47 }
8、基数排序
基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
\
1 public static void radixSort(int[] array) {
2 //首先确定排序的趟数;
3 int max = array[0];
4 for (int i = 1; i < array.length; i++) {
5 if (array[i] > max) {
6 max = array[i];
7 }
8 }
9 int time = 0;
10 //判断位数;
11 while (max > 0) {
12 max /= 10;
13 time++;
14 }
15
16
17 //建立10个队列;
18 ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
19 for (int i = 0; i < 10; i++) {
20 ArrayList<Integer> queue1 = new ArrayList<>();
21 queue.add(queue1);
22 }
23
24
25 //进行time次分配和收集;
26 for (int i = 0; i < time; i++) {
27 //分配数组元素;
28 for (int anArray : array) {
29 //得到数字的第time+1位数;
30 int x = anArray % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
31 ArrayList<Integer> queue2 = queue.get(x);
32 queue2.add(anArray);
33 queue.set(x, queue2);
34 }
35 int count = 0;//元素计数器;
36 //收集队列元素;
37 for (int k = 0; k < 10; k++) {
38 while (queue.get(k).size() > 0) {
39 ArrayList<Integer> queue3 = queue.get(k);
40 array[count] = queue3.get(0);
41 queue3.remove(0);
42 count++;
43 }
44 }
45 }
46 System.out.println(Arrays.toString(array) + " radixSort");
47 }
结果
**
**
附上以上所有排序整理结果：
1 package com.test.sort;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5
6 @SuppressWarnings("WeakerAccess")
7 public final class SortDemo {
8
9 // 排序原始数据
10 private static final int[] NUMBERS =
11 {49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
12
13
14 public static void main(String[] args) {
15 insertSort(NUMBERS);
16 shellSort(NUMBERS);
17 selectSort(NUMBERS);
18 bubbleSort(NUMBERS);
19 heapSort(NUMBERS);
20 quickSort(NUMBERS);
21 mergingSort(NUMBERS);
22 radixSort(NUMBERS);
23 }
24
25
26 public static void insertSort(int[] array) {
27 for (int i = 1; i < array.length; i++) {
28 int temp = array[i];
29 int j = i - 1;
30 for (; j >= 0 && array[j] > temp; j--) {
31 //将大于temp的值整体后移一个单位
32 array[j + 1] = array[j];
33 }
34 array[j + 1] = temp;
35 }
36 System.out.println(Arrays.toString(array) + " insertSort");
37 }
38
39
40 public static void shellSort(int[] array) {
41 int i;
42 int j;
43 int temp;
44 int gap = 1;
45 int len = array.length;
46 while (gap < len / 3) {
47 gap = gap * 3 + 1;
48 }
49 for (; gap > 0; gap /= 3) {
50 for (i = gap; i < len; i++) {
51 temp = array[i];
52 for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
53 array[j + gap] = array[j];
54 }
55 array[j + gap] = temp;
56 }
57 }
58 System.out.println(Arrays.toString(array) + " shellSort");
59 }
60
61 public static void selectSort(int[] array) {
62 int position = 0;
63 for (int i = 0; i < array.length; i++) {
64 int j = i + 1;
65 position = i;
66 int temp = array[i];
67 for (; j < array.length; j++) {
68 if (array[j] < temp) {
69 temp = array[j];
70 position = j;
71 }
72 }
73 array[position] = array[i];
74 array[i] = temp;
75 }
76 System.out.println(Arrays.toString(array) + " selectSort");
77 }
78
79
80 public static void bubbleSort(int[] array) {
81 int temp = 0;
82 for (int i = 0; i < array.length - 1; i++) {
83 for (int j = 0; j < array.length - 1 - i; j++) {
84 if (array[j] > array[j + 1]) {
85 temp = array[j];
86 array[j] = array[j + 1];
87 array[j + 1] = temp;
88 }
89 }
90 }
91 System.out.println(Arrays.toString(array) + " bubbleSort");
92 }
93
94
95 public static void heapSort(int[] array) {
96 /*
97 * 第一步：将数组堆化
98 * beginIndex = 第一个非叶子节点。
99 * 从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
100 * 叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
101 */
102 int len = array.length - 1;
103 int beginIndex = (len - 1) >> 1;
104 for (int i = beginIndex; i >= 0; i--) {
105 maxHeapify(i, len, array);
106 }
107 /*
108 * 第二步：对堆化数据排序
109 * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
110 * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
111 * 直至未排序的堆长度为 0。
112 */
113 for (int i = len; i > 0; i--) {
114 swap(0, i, array);
115 maxHeapify(0, i - 1, array);
116 }
117 System.out.println(Arrays.toString(array) + " heapSort");
118 }
119
120 private static void swap(int i, int j, int[] arr) {
121 int temp = arr[i];
122 arr[i] = arr[j];
123 arr[j] = temp;
124 }
125
126 /**
127 * 调整索引为 index 处的数据，使其符合堆的特性。
128 *
129 * @param index 需要堆化处理的数据的索引
130 * @param len 未排序的堆（数组）的长度
131 */
132 private static void maxHeapify(int index, int len, int[] arr) {
133 int li = (index << 1) + 1; // 左子节点索引
134 int ri = li + 1; // 右子节点索引
135 int cMax = li; // 子节点值最大索引，默认左子节点。
136 if (li > len) {
137 return; // 左子节点索引超出计算范围，直接返回。
138 }
139 if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。
140 {
141 cMax = ri;
142 }
143 if (arr[cMax] > arr[index]) {
144 swap(cMax, index, arr); // 如果父节点被子节点调换，
145 maxHeapify(cMax, len, arr); // 则需要继续判断换下后的父节点是否符合堆的特性。
146 }
147 }
148
149
150 public static void quickSort(int[] array) {
151 _quickSort(array, 0, array.length - 1);
152 System.out.println(Arrays.toString(array) + " quickSort");
153 }
154
155
156 private static int getMiddle(int[] list, int low, int high) {
157 int tmp = list[low]; //数组的第一个作为中轴
158 while (low < high) {
159 while (low < high && list[high] >= tmp) {
160 high--;
161 }
162
163
164 list[low] = list[high]; //比中轴小的记录移到低端
165 while (low < high && list[low] <= tmp) {
166 low++;
167 }
168
169
170 list[high] = list[low]; //比中轴大的记录移到高端
171 }
172 list[low] = tmp; //中轴记录到尾
173 return low; //返回中轴的位置
174 }
175
176
177 private static void _quickSort(int[] list, int low, int high) {
178 if (low < high) {
179 int middle = getMiddle(list, low, high); //将list数组进行一分为二
180 _quickSort(list, low, middle - 1); //对低字表进行递归排序
181 _quickSort(list, middle + 1, high); //对高字表进行递归排序
182 }
183 }
184
185
186 public static void mergingSort(int[] array) {
187 sort(array, 0, array.length - 1);
188 System.out.println(Arrays.toString(array) + " mergingSort");
189 }
190
191 private static void sort(int[] data, int left, int right) {
192 if (left < right) {
193 //找出中间索引
194 int center = (left + right) / 2;
195 //对左边数组进行递归
196 sort(data, left, center);
197 //对右边数组进行递归
198 sort(data, center + 1, right);
199 //合并
200 merge(data, left, center, right);
201 }
202 }
203
204 private static void merge(int[] data, int left, int center, int right) {
205 int[] tmpArr = new int[data.length];
206 int mid = center + 1;
207 //third记录中间数组的索引
208 int third = left;
209 int tmp = left;
210 while (left <= center && mid <= right) {
211 //从两个数组中取出最小的放入中间数组
212 if (data[left] <= data[mid]) {
213 tmpArr[third++] = data[left++];
214 } else {
215 tmpArr[third++] = data[mid++];
216 }
217 }
218
219 //剩余部分依次放入中间数组
220 while (mid <= right) {
221 tmpArr[third++] = data[mid++];
222 }
223
224 while (left <= center) {
225 tmpArr[third++] = data[left++];
226 }
227
228 //将中间数组中的内容复制回原数组
229 while (tmp <= right) {
230 data[tmp] = tmpArr[tmp++];
231 }
232 }
233
234
235 public static void radixSort(int[] array) {
236 //首先确定排序的趟数;
237 int max = array[0];
238 for (int i = 1; i < array.length; i++) {
239 if (array[i] > max) {
240 max = array[i];
241 }
242 }
243 int time = 0;
244 //判断位数;
245 while (max > 0) {
246 max /= 10;
247 time++;
248 }
249
250
251 //建立10个队列;
252 ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
253 for (int i = 0; i < 10; i++) {
254 ArrayList<Integer> queue1 = new ArrayList<>();
255 queue.add(queue1);
256 }
257
258
259 //进行time次分配和收集;
260 for (int i = 0; i < time; i++) {
261 //分配数组元素;
262 for (int anArray : array) {
263 //得到数字的第time+1位数;
264 int x = anArray % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
265 ArrayList<Integer> queue2 = queue.get(x);
266 queue2.add(anArray);
267 queue.set(x, queue2);
268 }
269 int count = 0;//元素计数器;
270 //收集队列元素;
271 for (int k = 0; k < 10; k++) {
272 while (queue.get(k).size() > 0) {
273 ArrayList<Integer> queue3 = queue.get(k);
274 array[count] = queue3.get(0);
275 queue3.remove(0);
276 count++;
277 }
278 }
279 }
280 System.out.println(Arrays.toString(array) + " radixSort");
281 }
282 }
