排序算法在日常的开发中十分常见。常见的七种排序算法有：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序。
还有另外三种排序算法：基数排序、计数排序、桶排序。
它们的特性如下：
目录
直接选择排序：
希尔排序：
简单选择排序：
堆排序：
冒泡排序：
快速排序：
归并排序：
基数排序：
计数排序：
桶排序：
首先我们讨论常见的七种排序算法：
直接选择排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 每次选择一个元素，并且将这个元素和整个数组中的所有元素进行比较，然后插入到合适的位置，
7. * 时间复杂度：平均： O(n^2)，最好：O(n)，最坏：O(n^2)，辅助空间：O（1），稳定
8. */
9. public class 插入排序 {
10. public void insert_sort(int[] nums) {
11. int i, j;
12. int length = nums.length;
13. for (i = 1; i < length; i++) {
14. int temp = nums[i];
15. for (j = i; j > 0 && nums[j - 1] > temp; j--) {
16. nums[j] = nums[j - 1];
17. }
18. nums[j] = temp;
19. }
20. }
21.
22. public static void main(String[] args) {
23. 插入排序 t1 = new 插入排序();
24. int[] arr = {52,5,8,6,2,5,4,2};
25. System.out.println(Arrays.toString(arr));
26.
27. t1.insert_sort(arr);
28. System.out.println(Arrays.toString(arr));
29. }
30. }希尔排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 插入排序的修改版，根据步长由长到短分组，进行排序，直到步长为1为止，属于插入排序的一种。
7. * 时间复杂度：平均：O(nlogn)-O(n^2),最好：O(n^1.3)，最坏：O(n^2)，辅助空间：O(1)，不稳定
8. */
9. public class 希尔排序 {
10. public void shellSort(int[] nums) {
11. int length = nums.length;
12.
13. for (int gap = length / 2; gap > 0; gap /= 2) {
14. for (int i = gap; i < length; i++) {
15. int temp = nums[i];
16. int j;
17. for (j = i; j >= gap && nums[j - gap] > temp; j -= gap) {
18. nums[j] = nums[j - gap];
19. }
20. nums[j] = temp;
21. }
22. }
23. }
24.
25. public static void main(String[] args) {
26. 希尔排序 t1 = new 希尔排序();
27. int[] nums = {5, 5, 2, 9, 3, 2, 3, 4, 8};
28. System.out.println(Arrays.toString(nums));
29. t1.shellSort(nums);
30. System.out.println(Arrays.toString(nums));
31.
32. }
33.
34.
35. }简单选择排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 通过 n-i 次关键字间的比较，从 n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换之
7. * 时间复杂度：平均：O(n^2)，最好：O(n^2)，最坏：O(n^2)，辅助空间：O(1)，稳定
8. */
9. public class 简单选择排序 {
10. private void selectSort(int[] nums) {
11. int i, j, min;
12. int length = nums.length;
13.
14. for (i = 0; i < length; i++) {
15. min = i;
16.
17. for (j = i + 1; j < length; j++) {
18. if (nums[min] > nums[j]) {
19. min = j;
20. }
21. }
22. if (min != i) {
23. swap(nums, min, i);
24. }
25. }
26. }
27.
28. private void swap(int[] nums, int min, int i) {
29. int temp = nums[min];
30. nums[min] = nums[i];
31. nums[i] = temp;
32. }
33.
34. public static void main(String[] args) {
35. 简单选择排序 t1 = new 简单选择排序();
36. int[] nums = {5,96,2,3,8,4,97};
37. System.out.println(Arrays.toString(nums));
38. t1.selectSort(nums);
39. System.out.println(Arrays.toString(nums));
40. }
41.
42. }堆排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 堆排序是一种基于二叉堆（Binary Heap）结构的排序算法，
7. * 所谓二叉堆，我们通过完全二叉树来对比，只不过相比较完全二叉树而言，二叉堆的所有父节点的值都大于（或者小于）它的孩子节点
8. * 首先需要引入最大堆的定义：
9. * 1、最大堆中的最大元素值出现在根结点（堆顶）
10. * 2、堆中每个父节点的元素值都大于等于其孩子结点
11. * <p>
12. * 堆排序的方法如下：把最大堆堆顶的最大数取出，将剩余的堆继续调整为最大堆，再次将堆顶的最大数取出，这个过程持续到剩余数只有一个时结束。
13. *
14. * 时间复杂度：平均：O(nlogn)，最好：O(nlogn)，最坏：O(nlogn)，辅助空间：O(1)，不稳定
15. */
16. public class 堆排序 {
17.
18. /**
19. * 建立堆函数，不断构建二叉堆
20. *
21. * @param nums：待排序的数组
22. * @param n：数组的长度
23. * @param i：数组中最大值的下标
24. */
25. public void heapify(int[] nums, int n, int i) {
26. int largest = i; //将最大元素设置为堆顶元素，假设现在nums[i]是最大元素
27. int l = 2 * i + 1; //left = 2*i+1，相当于左孩子
28. int r = 2 * i + 2; //right = 2*i+2，相当于右孩子
29.
30.
31. //如果 left 比 root 大的话
32. if (l < n && nums[l] > nums[largest]) {
33. largest = l;
34. }
35.
36. //如果 right 比 root 大的话
37. if (r < n && nums[r] > nums[largest]) {
38. largest = r;
39. }
40.
41. if (largest != i) {
42. swap(nums, i, largest);
43.
44. //递归的定义子堆
45. heapify(nums, n, largest);
46. }
47. }
48.
49. private void swap(int[] nums, int i, int largest) {
50. int temp = nums[i];
51. nums[i] = nums[largest];
52. nums[largest] = temp;
53. }
54.
55. /**
56. * 堆排序函数
57. *
58. * @param nums：待排序的数组
59. * @param n：数组的长度
60. */
61. public void heapSort(int[] nums, int n) {
62. //建立堆
63. for (int i = n / 2 - 1; i >= 0; i--) {
64. heapify(nums, n, i);
65. }
66.
67. //一个个从堆顶取出元素
68. for (int i = n - 1; i >= 0; i--) {
69. //将最大值放到最后一位，相当于把根节点与数组最后一位元素交换
70. swap(nums, 0, i);
71. //每次改变最大值的位置后，要重新构建二叉堆
72. heapify(nums, i, 0);
73. }
74. }
75.
76. public static void main(String[] args) {
77. 堆排序 t1 = new 堆排序();
78. int[] nums = {5, 9, 2, 6, 8, 4, 6, 2, 9};
79. System.out.println(Arrays.toString(nums));
80. t1.heapSort(nums, nums.length);
81. System.out.println(Arrays.toString(nums));
82. }
83. }冒泡排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 每次选择两个元素，按照需求进行交换（比如需要升序排列的话，把较大的元素放在靠后一些的位置），
7. * 循环 n 次（n 为总元素个数），这样小的元素会不断 “冒泡” 到前面来
8. * 时间复杂度：平均：O(n^2)，最好：O(n)，最坏：O(n^2)，辅助空间：O(1)，稳定
9. */
10. public class 冒泡排序 {
11.
12. public void bubbleSort(int[] nums) {
13. int length = nums.length;
14. boolean swap = true;
15. while (swap) {
16. swap = false;
17. for (int i = 0; i < length - 1; i++) {
18. if (nums[i] > nums[i + 1]) {
19. nums[i] += nums[i + 1];
20. nums[i + 1] = nums[i] - nums[i + 1];//这里已经将nums[i]的值赋给nums[i+1]
21. nums[i] -= nums[i + 1];//减去之后nums[i]的值已经变为原来的nums[i+1]
22. swap = true;
23. }
24. }
25. }
26. }
27.
28. public static void main(String[] args) {
29. 冒泡排序 t1 = new 冒泡排序();
30. int[] nums = {5, 6, 7, 6, 9, 4, 1, 7, 5};
31. System.out.println(Arrays.toString(nums));
32. t1.bubbleSort(nums);
33. System.out.println(Arrays.toString(nums));
34. }
35.
36.
37. }快速排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. *简称快排，时间复杂度并不固定，如果在最坏情况下（元素刚好是反向的）速度比较慢，达到 O(n^2)（和选择排序一个效率），但是如果在比较理想的情况下时间复杂度 O(nlogn)。
7. *
8. * 快排也是一个分治的算法，快排算法每次选择一个元素并且将整个数组以那个元素分为两部分，根据实现算法的不同，元素的选择一般有如下几种：
9. *
10. * 永远选择第一个元素
11. * 永远选择最后一个元素
12. * 随机选择元素
13. * 取中间值
14. * 整个快速排序的核心是分区（partition），分区的目的是传入一个数组和选定的一个元素，把所有小于那个元素的其他元素放在左边，大于的放在右边。
15. *
16. * 其思路是每次从最左元素中选择一个元素并且将小于等于那个元素的元素的下标标记为 i ，在整个遍历过程中，如果我们找到一个更加小的元素，我们就把这
17. * 个元素和数组中第 i 个元素交换
18. */
19. public class 快速排序 {
20.
21. /**
22. * 排序函数
23. *
24. * @param nums：待排序的数组
25. * @param low：低位
26. * @param high：高位
27. */
28. public void quickSort(int[] nums, int low, int high) {
29. int pivot;
30. if (low < high) {
31. pivot = partition(nums, low, high);
32.
33. quickSort(nums, low, pivot - 1);
34.
35. quickSort(nums, pivot + 1, high);
36. }
37. }
38.
39. /**
40. * 分区函数
41. * @param nums：
42. * @param low：
43. * @param high：
44. * @return
45. */
46. public int partition(int[] nums, int low, int high) {
47. int pivotkey;
48.
49. pivotkey = nums[low]; //用子表的第一个记录作为枢轴记录
50. while (low < high) { //从表的两端交替向中间扫描
51. while (low < high && nums[high] >= pivotkey) {
52. high--;
53. }
54. swap(nums, low, high); //将比枢轴记录小的记录交换到低端
55. while (low < high && nums[low] <= pivotkey) {
56. low++;
57. }
58. swap(nums, low, high); //将比枢轴记录大的记录交换到高端
59. }
60. return low; //返回枢轴所在位置
61. }
62.
63. private void swap(int[] nums, int i, int largest) {
64. int temp = nums[i];
65. nums[i] = nums[largest];
66. nums[largest] = temp;
67. }
68.
69. public static void main(String[] args) {
70. 快速排序 t1 = new 快速排序();
71. int[] nums = {5,7,6,2,3,98,6,21};
72. System.out.println(Arrays.toString(nums));
73. t1.quickSort(nums,0,nums.length-1);
74. System.out.println(Arrays.toString(nums));
75. }
76.
77.
78. }归并排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 归并排序相比较之前的排序算法而言加入了分治法的思想，其算法思路如下：
7. * <p>
8. * 1.如果给的数组只有一个元素的话，直接返回（也就是递归到最底层的一个情况）
9. * <p>
10. * 2.把整个数组分为尽可能相等的两个部分（分）
11. * <p>
12. * 3.对于两个被分开的两个部分进行整个归并排序（治）
13. * <p>
14. * 4.把两个被分开且排好序的数组拼接在一起
15. *
16. * 时间复杂度：平均：O(nlogn)，最好：O(nlogn)，最坏：O(nlogn)，辅助空间：O(n)，稳定
17. */
18. public class 归并排序 {
19.
20. public void merge(int[] nums, int l, int m, int r) {
21. int i, j, k;
22. int n1 = m - l + 1;
23. int n2 = r - m;
24.
25. int[] L = new int[n1];
26. int[] R = new int[n2];
27.
28. for (int n = 0; n < n1; n++) {
29. L[n] = nums[l + n];
30. }
31.
32. for (int n = 0; n < n2; n++) {
33. R[n] = nums[m + 1 + n];
34. }
35.
36. i = 0;
37. j = 0;
38. k = l;
39.
40. while (i < n1 && j < n2) {
41. if (L[i] <= R[j]) {
42. nums[k] = L[i];
43. i++;
44. } else {
45. nums[k] = R[j];
46. j++;
47. }
48. k++;
49. }
50.
51. while (i < n1) {
52. nums[k] = L[i];
53. i++;
54. k++;
55. }
56.
57. while (j < n2) {
58. nums[k] = R[j];
59. j++;
60. k++;
61. }
62.
63. }
64.
65. public void mergeSort(int[] nums, int l, int r) {
66. if (l < r) {
67. int m = l + (r - l) / 2;
68. mergeSort(nums, l, m);
69. mergeSort(nums, m + 1, r);
70.
71. merge(nums, l, m, r);
72. }
73. }
74.
75. public static void main(String[] args) {
76. 归并排序 t1 = new 归并排序();
77. int[] nums = {1, 5, 7, 6, 3, 8, 9, 5, 2, 7, 6};
78. int length = nums.length;
79. System.out.println(Arrays.toString(nums));
80. t1.mergeSort(nums,0,length-1);
81. System.out.println(Arrays.toString(nums));
82. }
83.
84. }另外三种排序算法Java实现如下：
基数排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
7. * 排序过程是将所有待比较数值统一为同样的数位长度，数位较短的数前面补零，然后从最低位开始，依次进行一次排序。
8. * 这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
9. */
10.
11. public class 基数排序 {
12. private int getMax(int[] arr) {
13. int max = arr[0];
14. int length = arr.length;
15.
16. for (int i = 1; i < length; i++) {
17. if (arr[i] > max) {
18. max = arr[i];
19. }
20. }
21. return max;
22. }
23.
24. private void countSort(int[] arr, int n, int exp) {
25. int output[] = new int[n];
26. int i;
27. int[] count = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
28.
29. for (int j = 0; j < n; j++) {
30. count[(arr[j] / exp) % 10]++;
31. }
32.
33. for (int j = 1; j < 10; j++) {
34. count[j] += count[j - 1];
35. }
36.
37. for (int j = n - 1; j >= 0; j--) {
38. output[count[(arr[j] / exp) % 10] - 1] = arr[j];
39. count[(arr[j] / exp) % 10]--;
40. }
41.
42. for (int j = 0; j < n; j++) {
43. arr[j] = output[j];
44. }
45. }
46.
47. private void radixSort(int[] arr, int n) {
48. int m = getMax(arr);
49.
50. for (int exp = 1; m / exp > 0; exp *= 10) {
51. countSort(arr, n, exp);
52. }
53. }
54.
55. public static void main(String[] args) {
56. 基数排序 t1 = new 基数排序();
57. int[] arr = {6, 8, 6, 1, 3, 7, 9, 2, 3, 55, 23};
58. System.out.println(Arrays.toString(arr));
59. int length = arr.length;
60. t1.radixSort(arr, length);
61. System.out.println(Arrays.toString(arr));
62. }
63. }计数排序：
1. package 排序算法;
2.
3. /**
4. * 计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数
5. * （此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。
6. * 一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。
7. * 例如，如果输入序列中只有17个元素的值小于x 的值，则 x 可以直接存放在输出序列的第18个位置上。
8. * 当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上,
9. * 优化后的计数排序算法如下：时间复杂度为Ο(n+k)（其中k是整数的范围），稳定
10. */
11. public class 计数排序 {
12. public static int[] countSort(int[] a) {
13. int b[] = new int[a.length];
14. int max = a[0], min = a[0];
15. for (int i : a) {
16. if (i > max) {
17. max = i;
18. }
19. if (i < min) {
20. min = i;
21. }
22. }
23. //这里k的大小是要排序的数组中，元素大小的极值差+1
24. int k = max - min + 1;
25. int c[] = new int[k];
26. for (int i = 0; i < a.length; ++i) {
27. c[a[i] - min] += 1;//优化过的地方，减小了数组c的大小
28. }
29. for (int i = 1; i < c.length; ++i) {
30. c[i] = c[i] + c[i - 1];
31. }
32. for (int i = a.length - 1; i >= 0; --i) {
33. b[--c[a[i] - min]] = a[i];//按存取的方式取出c的元素
34. }
35. return b;
36. }
37.
38. public static void main(String[] args) {
39. //排序的数组
40. int a[] = {100, 93, 97, 92, 96, 99, 92, 89, 93, 97, 90, 94, 92, 95};
41. int b[] = countSort(a);
42. for (int i : b) {
43. System.out.print(i + " ");
44. }
45. System.out.println();
46. }
47. }桶排序：
1. package 排序算法;
2.
3. import java.util.Arrays;
4.
5. /**
6. * 桶排序的思路：首先找到数组中的最大值，然后新建一个数组，bucket 此数组的长度是数组最大值+1，其实新建的这个数组中的下标值就是原数组的数据值，这里为什么长度是数组最大值加一呢
7. * 注意*：是因为比如数组最大值是9，然后如果你设置bucket数组的长度为9，那么他的下标最大值就是8，那么原数组的9 就没有桶存了
8. * 好了继续，找到最大值后，开始遍历原数组，把原数组的数据加入bucket的下表中，bucket[i]，每当有1个i bucket[i]的值就加一，
9. * 然后已经装入桶后， 遍历桶，如果bucket[j]位置-->0就说明此下标有数据，也就是说，此下标在原数组里有这个值， 然后排序 就是从大到小了 arr[i++]=j;
10. *
11. * 时间复杂度：O(n)，辅助空间：O(n)，不稳定
12. *
13. */
14. public class 桶排序 {
15. public void bucketSort(int[] arr) {
16. int length = arr.length;
17.
18. int max = Integer.MIN_VALUE;
19.
20. for (int i = 0; i < length; i++) {
21.
22. max = Math.max(max, arr[i]);
23. }
24.
25. int[] bucket = new int[max + 1];
26.
27. for (int i = 0; i < length; i++) {
28. bucket[arr[i]]++;
29. }
30.
31. int i = 0;
32. for (int j = 0; j < bucket.length; j++) {
33. while (bucket[j]-- > 0) {
34. arr[i++] = j;
35. }
36. }
37. }
38.
39. public static void main(String[] args) {
40. 桶排序 t1 = new 桶排序();
41. int[] nums = {5, 6, 87, 9, 3, 1};
42. System.out.println(Arrays.toString(nums));
43. t1.bucketSort(nums);
44. System.out.println(Arrays.toString(nums));
45. }
46. }
以上就是对这十大排序算法的概括。相比之下，从最好情况看，反而冒泡和直接插入排序要更胜一筹，也就是说，如果你的待排序序列总是基本有序，优先考虑这两种排序算法。
从最坏情况看，堆排序与归并排序又强过快速排序以及其他简单排序。
从待排序记录的个数上来说，待排序的个数n越小，采用简单排序方法（如冒泡排序、简单选择排序、直接插入排序）越合适。反之，n越大，采用改进排序方法越合适。所以在使用快速排序等复杂排序算法时，可以增加一个阈值，低于阈值时换做简单排序算法可提高效率。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
