算法基础-排序

很多计算机科学家认为 排序 是 算法研究中最基础的问题^[1].

如果输入数组中仅有 常数 个元素需要在排序过程中存储在数组之外, 则称排序算法是 原址的(in place).

比较排序: 在排序的最终结果中, 各元素的次序依赖于它们之间的 比较.
非比较排序(运算排序): 用 运算 而不是比较来确定排序顺序.

下表总结了常见的比较算法:

算法	特性描述	最坏情况运行时间	平均情况运行时间
冒泡排序	原址, 比较	O(n2)	O(n2)
梳排序	原址, 比较	O(n2)	O(n2/2p)
插入排序	原址, 比较	O(n2)	O(n2)
归并排序	比较	O(nlgn)	O(nlgn)
堆排序	原址,比较	O(nlgn)	-
快速排序	原址,比较	O(n2)	O(nlgn))
计数排序	非比较	O(k+n)	O(k+n)
基数排序	非比较	O(d(n+k))	O(d(n+k))
桶排序	非比较	O(n2)	O(n)

1 冒泡排序

冒泡排序(Bubble Sort) 是很多人学习的第一个排序算法. 其思想很简单:
对 具有n个元素的数组 进行n-1轮操作, 每一轮操作都把 (当前轮的)最大元素 放在 (当前轮的)最后.

看个示例图^[2]:

代码实现:

public class BubbleSort {
    public int[] sort(int[] a) {
        if (a.length <= 1) {
            return a;
        }
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; j < a.length - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        return a;
    }

    public static void main(String[] args) {
        int[] a = {4, 5, 1, 2, 7, 11, 3};
        BubbleSort bubbleSort = new BubbleSort();
        System.out.println(Arrays.toString(bubbleSort.sort(a)));
    }
}

2 梳排序

简介:
梳排序(Comb sort)是一种由 Dobosiewicz 于1980年所发明的不稳定排序算法.
梳排序在进行冒泡排序之前, 可以保证序列头部是小数, 序列尾部是大数.

梳排序(Comb sort)是冒泡排序的改良.
试想如果 待排序的数组是逆序的, 那么冒泡排序每轮内部循环都会交换元素, 这会使排序效率降低.

梳排序 的思想:
设置一个 gap(间隔), 每次比较 下标i 和 下标i+gap 两个元素的值, 并确定要不要交换.
冒泡排序就是固定 gap=1的梳排序.
梳排序中 的 gap 是动态变化的, 通常 gap 的取值是: 初始 a.length/1.3, 每趟比较后 gap减少 1.3 倍.

看个示例图^[3], 下图两条红线之间就是 gap 的大小:

代码实现:

public class CombSort {
    public static final float SHRINK_FACTOR = 1.3f;

    public int[] sort(int[] a) {
        int gap = a.length;

        while (gap > 0) {
            gap = (int) (gap / SHRINK_FACTOR);
            for (int i = 0; i < a.length - gap; i++) {
                if (a[i] > a[i + gap]) {
                    int temp = a[i];
                    a[i] = a[i + gap];
                    a[i + gap] = temp;
                }
            }
        }
        return a;
    }

    public static void main(String[] args) {
        int[] a = {4, 5, 1, 2, 7, 11, 3};
        CombSort combSort = new CombSort();
        System.out.println(Arrays.toString(combSort.sort(a)));
    }
}

3 插入排序

插入排序(Insertion sort) 的思想和 打扑克时抓牌放入手中 的思想是一样的:
抓第1张牌时, 是有序的;
抓第2张牌时, 需要和前面的牌做比较: 如果这张牌是当前最大的, 放在最后即可; 如果不是最大的则需要把前面的牌后移, 找到一个合适的位置插入.
后面抓牌重复抓第2张牌相同的操作…

插入排序操作示意图:

插入排序代码实现:

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

    public static void main(String[] args) {
        int[] a = {4, 5, 1, 2, 7, 11, 3};
        InsertionSort insertionSort = new InsertionSort();
        System.out.println(Arrays.toString(insertionSort.sort(a)));
    }
}

4 归并排序

归并排序

5 堆排序

堆排序

6 快速排序

快速排序

7 非比较排序

非比较排序

Reference

[1]. 算法导论(第三版)
[2]. 值得收藏的十大经典排序算法-Java资讯库
[3]. Comb sort-wikipedia