By的博客
0%

排序算法

发表于 更新于 分类于

排序算法说明

排序的定义

对一序列对象根据某个关键字进行排序。

术语说明

  • 稳定 ：如果a原本在b前面，并且a=b，则排序之后a仍然在b的前面；
  • 不稳定 ：如果a原本在b的前面，而a=b，则排序之后a可能会出现在b的后面；
  • 内排序 ：所有排序操作都在内存中完成；
  • 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
  • 时间复杂度 ： 一个算法执行所耗费的时间。
  • 空间复杂度 ：运行完一个程序所需内存的大小。

算法复杂度总结

算法复杂度

图片名词解释：

  • n: 数据规模
  • k: “桶”的个数
  • In-place: 占用常数内存，不占用额外内存
  • Out-place: 占用额外内存

比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序 等属于比较排序 。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置 。

在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。

比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序 。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置 。

非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。

非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

  1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  3. 针对所有的元素重复以上的步骤，除了最后一个（此时最后一个是最大的元素）；
  4. 重复步骤1~3，直到排序完成。

动图演示

冒泡排序

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int[] bubbleSort(int[] array) {
    if (array.length == 0){
        return array;
    }
    //一共需要array.length次循环
    for (int i = 0; i < array.length; i++){
        //每次冒泡去除后面i个元素
        for (int j = 0; j < array.length - 1 - i; j++)
            //如果当前元素大于下一个元素则交换
            if (array[j] > array[j + 1]) {
                int temp = array[j + 1];
                array[j + 1] = array[j];
                array[j] = temp;
            }
    }
    return array;
}

选择排序（Selection Sort）

选择排序是表现最稳定的排序算法之一 ，因为无论什么数据进去都是O(n^2^)的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处就是不占用额外的内存空间。

算法描述

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  2. 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的下一位
  3. 以此类推，直到所有元素均排序完毕

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第i个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

动图演示

选择排序

代码实现 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static int[] selectionSort(int[] array) {
    if (array.length == 0){
        return array;
    }
    //一共需要array.length次循环
    for (int i = 0; i < array.length; i++) {
        //记录最小值的下标
        int minIndex = i;
        //从i开始往后为无序区
        for (int j = i; j < array.length; j++) {
            //找到最小的数
            if (array[j] < array[minIndex]) 
                //将最小数的索引保存
                minIndex = j; 
        }
        //将array[i]与array[minIndex]交换
        int temp = array[minIndex];
        array[minIndex] = array[i];
        array[i] = temp;
    }
    return array;
}

插入排序（Insertion Sort）

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后移，为新元素提供插入空间。

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

  1. 从第一个元素开始，该元素可以认为已经被排序；
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  5. 将新元素插入到该位置后；
  6. 重复步骤2~5。

动图演示

插入排序

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static int[] insertionSort(int[] array) {
    if (array.length == 0){
        return array;
    }
    //记录当前指针所指的位置
    int current;
    //从1开始
    for (int i = 1; i < array.length; i++) {
        //提前当前元素的值，避免被后移元素覆盖而丢失
        current = array[i];
        //前一个元素
        int preIndex = i - 1;
        //当存在前一个元素并且当前值小于他时不断进行元素后移
        while (preIndex >= 0 && current < array[preIndex]) {
            //元素后移
            array[preIndex + 1] = array[preIndex];
            preIndex--;
        }
        //current > array[preIndex]或者preIndex == -1,则把current放在preIndex后一位
        array[preIndex + 1] = current;
    }
    return array;
}

希尔排序（Shell Sort）

希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n^2^)的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。

希尔排序是把记录按一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

算法描述

在此我们选择增量 gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

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

过程演示

希尔排序

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static int[] ShellSort(int[] array) {
    int len = array.length;
    int temp, gap = len / 2;
    while (gap > 0) {
        //插入排序思想
        for (int i = gap; i < len; i++) {
            temp = array[i];
            //前一个元素
            int preIndex = i - gap;
            while (preIndex >= 0 && array[preIndex] > temp) {
                array[preIndex + gap] = array[preIndex];
                preIndex -= gap;
            }
            array[preIndex + gap] = temp;
        }
        gap /= 2;
    }
    return array;
}

归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。

归并排序 是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2路归并。

算法描述

  1. 把长度为n的输入序列分成两个长度为n/2的子序列；
  2. 对这两个子序列分别采用归并排序；
  3. 将两个排序好的子序列合并成一个最终的排序序列。

动图演示

归并排序

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static int[] MergeSort(int[] array) {
    if (array.length <= 1) return array;
    int mid = array.length / 2;
    //分为左右两部分，左闭右开
    int[] left = Arrays.copyOfRange(array, 0, mid);
    int[] right = Arrays.copyOfRange(array, mid, array.length);
    //递归
    return merge(MergeSort(left), MergeSort(right));
}
//合并
public static int[] merge(int[] left, int[] right) {
    //创建新数组保存合并数据
    int[] result = new int[left.length + right.length];
    //用三个指针来合并数组,分别指向合并后的数组、左数组和右数组
    for (int index = 0, i = 0, j = 0; index < result.length; index++) {
        //左数组为空或者全部添加完毕，直接复制右数组
        if (i >= left.length)
            result[index] = right[j++];
        //右数组为空或者全部添加完毕，直接复制左数组
        else if (j >= right.length)
            result[index] = left[i++];
        //右数组当前元素小，添加右数组元素
        else if (right[j] < left[i])
            result[index] = right[j++];
        //左数组当前元素小，添加左数组元素
        else
            result[index] = left[i++];
    }
    return result;
}

快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

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

动图演示

快速排序

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
private static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        // 找寻基准数据的正确索引
        int index = getIndex(arr, low, high);
        // 进行迭代对index之前和之后的数组进行相同的操作使整个数组变成有序
        quickSort(arr, low, index - 1);
        quickSort(arr, index + 1, high);
    }
}
//选取基准数据进行分割，返回基准数据的正确位置
private static int getIndex(int[] arr, int low, int high) {
    // 基准数据，取第一个元素
    int tmp = arr[low];
    //当low和high指针没有相遇时不断循环
    while (low < high) {
        // 当队尾的元素大于等于基准数据时,向前挪动high指针
        while (low < high && arr[high] >= tmp) {
            high--;
        }
        // 如果队尾元素小于tmp了,将其赋值给low
        arr[low] = arr[high];
        // 当队首元素小于等于tmp时,向前挪动low指针
        while (low < high && arr[low] <= tmp) {
            low++;
        }
        // 当队首元素大于tmp时,将其赋值给high
        arr[high] = arr[low];
    }
    // 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置，将tmp赋值给arr[low]
    //将基准数据放在正确的位置
    arr[low] = tmp;
    // 返回tmp的正确位置
    return low; 
}

堆排序（Heap Sort）

堆是一个树形结构，其实堆的底层是一棵完全二叉树。而完全二叉树是一层一层按照进入的顺序排成的。按照这个特性，我们可以用数组来按照完全二叉树实现堆。

算法思想：

  1. 构建初始堆，将待排序列构成一个大顶堆(或者小顶堆)，升序大顶堆，降序小顶堆；
  2. 将堆顶元素与堆尾元素交换，并断开(从待排序列中移除)堆尾元素。
  3. 重新构建堆。
  4. 重复2~3，直到待排序列中只剩下一个元素(堆顶元素)。

动图演示

堆排序

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {16, 7, 3, 20, 17, 8};

        heapSort(arr);

        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    /**
     * 创建堆，
     * @param arr 待排序列
     */
    private static void heapSort(int[] arr) {
        //创建堆
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr, i, arr.length);
        }

        //调整堆结构+交换堆顶元素与末尾元素
        for (int i = arr.length - 1; i > 0; i--) {
            //将堆顶元素与末尾元素进行交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;

            //重新对堆进行调整
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * 调整堆
     * @param arr 待排序列
     * @param parent 父节点
     * @param length 待排序列尾元素索引
     */
    private static void adjustHeap(int[] arr, int parent, int length) {
        //将temp作为父节点
        int temp = arr[parent];
        //左孩子
        int lChild = 2 * parent + 1;

        while (lChild < length) {
            //右孩子
            int rChild = lChild + 1;
            // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
            if (rChild < length && arr[lChild] < arr[rChild]) {
                lChild++;
            }

            // 如果父结点的值已经大于孩子结点的值，则直接结束
            if (temp >= arr[lChild]) {
                break;
            }

            // 把孩子结点的值赋给父结点
            arr[parent] = arr[lChild];

            //选取孩子结点的左孩子结点,继续向下筛选
            parent = lChild;
            lChild = 2 * lChild + 1;
        }
        arr[parent] = temp;
    }
}