十大经典排序算法

---

前言

相信大家都知道数据结构与算法的重要性了，排序算法是《数据结构与算法》中最基本的算法之一，接下来就让我们一起复习一下排序算法吧（其实也是自己忘的差不多了，顺便也温习一下），用一张图概括：

---

一、回顾一下有哪些排序算法

1.冒泡排序

1.1 算法步骤

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

1.2 动画演示

1.3 代码示例

package com.zyy.sort;

public class BubbleSort {
    public static int[] sort(int[] numbers) {
        for (int i = 1; i < numbers.length; i++) {
            // 假设元素有序
            boolean flag = true;
            for (int j = 0; j < numbers.length - i; j++) {
                // 升序
                if (numbers[j] > numbers[j + 1]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                    flag = false;
                }
            }
            // 如果有序则不进行比较
            if (flag) {
                break;
            }
        }
        return numbers;
    }
}

2.选择排序

2.1 算法步骤

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 重复第二步，直到所有元素均排序完毕。

2.2 动画演示

2.3 代码示例

package com.zyy.sort;

public class SelectionSort {
    public static int[] sort(int[] numbers) {
        int min;
        // 用于记录最小值的索引
        int record = 0;
        // 升序
        for (int i = 0; i < numbers.length; i++) {
            min = numbers[i];
            for (int j = i + 1; j < numbers.length; j++) {
                if (min > numbers[j]) {
                    record = j;
                }
            }
            int temp = numbers[i];
            numbers[i] = numbers[record];
            numbers[record] = temp;
        }
        return numbers;
    }
}

3.希尔排序

3.1 算法步骤

• 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
• 按增量序列个数 k，对序列进行 k 趟排序；
• 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1
  时，整个序列作为一个表来处理，表长度即为整个序列的长度。

3.2 过程图示

希尔排序是插入排序的改良版，交换不相邻的元素对数组的局部进行排序，并最终用插入排序将局部有序的数组排序。
在此我们选择增量 gap = length / 2，缩小增量以 gap = gap / 2 的方式，用序列 {n/2,(n/2)/2…1} 来表示。
（1）初始增量第一趟，增量为 4，gap = length / 2 = 4

（2）第二趟，增量缩小为 2，gap = gap / 2

（3）第三趟，增量缩小为 1，得到最终排序结果， gap = gap / 2

3.3 代码示例

package com.zyy.sort;

public class ShellSort{
    public static int[] sort(String[] args) {
        int[] numbers = {6, 8, 2, 1};
        for (int i = numbers.length / 2; i > 0; i /= 2) {
            for (int j = 0; j < numbers.length - i; j++) {
                if (numbers[j] > numbers[j + i]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j + i];
                    numbers[j + i] = temp;
                }
            }
        }
    }
}

4.快速排序

4.1 算法步骤

• 从数列中选择一个元素作为基准值（一般取第一个元素）。
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置，这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

4.2 动画演示

4.3 代码示例

package com.zyy.sort;

public class QuickSort {
    public static void sort(int left, int right, int[] numbers) {
        if (left >= right) {
            return;
        }
        int i = left, j = right;
        int temp = numbers[left];
        while (i < j) {
            // 从右往左找比基准值小的数
            while (i < j && numbers[j] < temp) {
                j--;
            }
            if (i < j && numbers[j] > temp) {
                numbers[i] = numbers[j];
            }
            // 从左往右找比基准值大的数
            while (i < j && numbers[i] > temp) {
                i++;
            }
            if (i < j && numbers[i] < temp) {
                numbers[j] = numbers[i];
            }
        }
        // 基准值归位
        numbers[j] = temp;
        sort(left, j - 1, numbers);
        sort(j + 1, right, numbers);
    }
}

5.插入排序

插入排序，一般也被称为直接插入排序，对于少量元素的排序，它是一个有效的算法。

5.1 算法步骤

• 将第一个元素看做一个有序序列（假设第一个元素有序），把第二个元素到最后一个元素当成是未排序序列。
• 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面）

5.2 动画演示

5.3 代码示例

package com.zyy.sort;

public class InsertionSort {
    public static int[] sort(int[] numbers) {
        for (int i = 1; i < numbers.length; i++) {
            int j = i - 1;
            while (j >= 0 && numbers[i] < numbers[j]) {
                int temp = numbers[i];
                numbers[i] = numbers[j];
                numbers[j] = temp;
                j--;
            }
        }
        return numbers;
    }
}

6.归并排序

6.1 算法步骤

• 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。
• 设定两个指针，最初位置分别为两个已经排序序列的起始位置。
• 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
• 重复步骤 3 直到某一指针达到序列尾。
• 将另一序列剩下的所有元素直接复制到合并序列尾。

6.2 动画演示

6.3 代码示例

package com.zyy.sort;

import java.util.Arrays;
 
/**
 * 归并排序
 */
public class MergeSort {
 
    // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
    private static void merge(Comparable[] arr, int l, int mid, int r) {
 
        Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);
 
        // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
        int i = l, j = mid + 1;
        for (int k = l; k <= r; k++) {
 
            if (i > mid) {  // 如果左半部分元素已经全部处理完毕
                arr[k] = aux[j - l];
                j++;
            } else if (j > r) {   // 如果右半部分元素已经全部处理完毕
                arr[k] = aux[i - l];
                i++;
            } else if (aux[i - l].compareTo(aux[j - l]) < 0) {  // 左半部分所指元素 < 右半部分所指元素
                arr[k] = aux[i - l];
                i++;
            } else {  // 左半部分所指元素 >= 右半部分所指元素
                arr[k] = aux[j - l];
                j++;
            }
        }
    }
 
    // 递归使用归并排序,对arr[l...r]的范围进行排序
    private static void sort(Comparable[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int mid = (l + r) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);
        // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
        // 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
        if (arr[mid].compareTo(arr[mid + 1]) > 0)
            merge(arr, l, mid, r);
    }
 
    public static void sort(Comparable[] arr) {
        int n = arr.length;
        sort(arr, 0, n - 1);
    }
}

7.堆排序

8.计数排序

9.桶排序

10.基数排序

---

总结

以上就是对常用排序算法的简单介绍，并且也附有相应的代码示例，希望能帮助到大家。还有几个就没有写了，有需要的再自己查阅相关资料吧。