【数据结构与算法 | 排序篇】排序算法

1. 排序

下面逐一写上述的排序算法。

注意：稳定和不稳定的依据是，相同的两个值，比如4*（*是为了区分后者的4，没其他特殊含义）， 4，如果在排序前，4*在4的前面，排序后，4*依然在4的前面，则该排序是稳定的排序；否则是不稳定的。

1). 改进的冒泡排序

要点：

• 每轮冒泡不断比较相邻的两个元素，如果它们是逆序的，则交换它们的位置。
• 下一轮冒泡，可以调整未排序的右边界（即边界右边的部分是已经排序了的），减少了不必要的比较。

以数组3，2，1的冒泡排序为例，

第一轮冒泡：

第二轮冒泡：

未排序区域就剩下一个元素，结束。

优化手段：每次循环时，若能确定更合适的右边界，则可以减少很多冒泡轮数。

以数组3， 2， 1，4， 5为例，第一轮结束后记录的x即为右边界：

代码：

public void BubbleSort(int[] nums) {
        int j = nums.length - 1;
        int x = 0;
        while (true) {
            for (int i = 0; i < j; i++) {
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i+1];
                    nums[i+1] = temp;
                    x = i;
                }
            }
            // 更新未排序的右边界
            j = x;
            // 此时说明已经全部排序完了
            if (j == 0) {
                break;
            }
        }
    }

2). 选择排序

要点：从数组中选出最大（最小）的元素，交换到合适的位置

public void SelectionSort(int[] nums) {
        // 从索引nums.length - 1开始比较，如果遇到比它还大的元素就交换
        // 一共比较nums.length - 1,索引0处不需要比较了
        // 每次将最大的元素放在后面
        for (int i = nums.length - 1; i > 0; i--) {
            int max = i;
            for (int j = 0; j < i; j++) {
                if (nums[max] < nums[j]) {
                    max = j;
                }
            }
            swap(nums, max, i);
        }
    }
    private void swap(int[] nums, int i, int j) {
        int temp;
        temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

3). 堆排序

下面代码实现的是小顶堆，需要完成堆化，和下沉的代码。

public void HeapSort(int[] nums) {
        heapify(nums);
    }
    //堆化
    public void heapify(int[] nums) {
        int size = nums.length;
        //第一步 : 找到最后一个非叶子节点
        //第二步 : 从该节点出发, 从后往前, 以此堆化
        //size - 1即最后一个叶子节点, 依据公式, 该则为叶子节点的父亲节点
        for (int parent = (size - 1) / 2; parent >= 0; parent--) {
            int leftChild = parent*2 + 1;
            int rightChild = parent*2 + 2;
            int min = parent;
            //如果存在左孩子, 而且父亲节点比孩子节点要大
            if (leftChild < size && nums[min] > nums[leftChild]) {
                min = leftChild;
            }
            //如果存在右孩子, 而且右孩子的值比左孩子和父亲还要小
            if (rightChild < size && nums[min] > nums[rightChild]) {
                min = rightChild;
            }
            //如果最小值不是父亲, 那么需要下沉
            if (min != parent) {
                down(parent, nums, size);
            }
        }
    }
    private void down(int parent, int[] nums, int size) {
        int leftChild = parent*2 + 1;
        int rightChild = parent*2 + 2;
        int min = parent;
        if (leftChild < size && nums[min] > nums[leftChild]) {
            min = leftChild;
        }
        if (rightChild < size && nums[min] > nums[rightChild]) {
            min = rightChild;
        }
        if (min != parent) {
            swap(nums, min, parent);
            down(min, nums, size);
        }
    }

4). 插入排序

要点：

• 将数组分为两部分[0, low-1], [low, a.length-1]，左边[0, low-1]是已经排序的部分，右边[low, a.length-1]是未排序的部分。
• 每次从未排序区域取出low位置的元素，插入到已经排序区域。

public void InsertSort(int[] nums) {
        for (int low = 1; low < nums.length; low++) {
            int t = nums[low];
            int i = low - 1;
            // 如果满足条件，即不断把小于low的元素右移
            while (i >= 0 && t < nums[i]){
                nums[i+1] = nums[i];
                i--;
            }
            // 找到了插入位置，插入其中
            if (i != low - 1){
                nums[i+1] = t;
            }
        }
    }

5). 希尔排序（改进的插入排序）

要点：

• 简单的说，就是分组实现插入，每组元素间隙为gap。
• 每轮排序后gap逐渐减小，直至gap为1完成排序。
• 对插入排序的优化，让元素更快速的交换到最终的位置。

推演：

gap = nums.length/2等于4开始，low为4，将5和9进行插入排序，继续将3和8进行插入排序...

gap=gap/2等于2，low为2，1， 5， 9， 7进行插入排序，继续将3， 2， 8， 4进行插入排序....

gap=gap/2等于1，low为1，即普通的插入排序。

图：

代码：

public void ShellSort(int[] nums) {
        for (int gap = nums.length >> 1; gap >= 1; gap = gap >> 1){
            for (int low = gap; low < nums.length; low += gap) {
                int t = nums[low];
                int i = low - gap;
                // 如果满足条件，即不断把小于low的元素右移
                while (i >= 0 && t < nums[i]){
                    nums[i+gap] = nums[i];
                    i -= gap;
                }
                // 找到了插入位置，插入其中
                if (i != low - gap){
                    nums[i+gap] = t;
                }
            }
        }
    }

6). 归并排序

（自上而下）

要点：

• 分：每次从中间切一刀，处理的数据少一半
• 治：当数据仅剩一个时可以认为有序。
• 合：两个有序的结果，可以进行合并。

代码：

public void MergeSortTopDown(int[] nums) {
        int[] temp = new int[nums.length];
        split(nums, 0, nums.length - 1, temp);
    }
    private void split(int[] nums, int left, int right, int[] temp) {
        // 治:只有一个数据，此时说明有序，返回
        if (left == right) {
            return;
        }
        // 分
        int mid = (left + right) / 2;
        split(nums, left, mid, temp);
        split(nums, mid+1, right, temp);
        // 合：处理分裂的元素
        merge(nums, left, mid, mid+1, right, temp);
        // 将temp数组的元素复制到nums数组上
        System.arraycopy(temp, left, nums, left, right - left + 1);
    }
    public static void merge(int[] nums, int i, int iEnd, int j, int jEnd, int[] temp){
        int k = i;
        // 如果两个数组的指针都未超出边界，则两个指针指向的元素进行比较，谁小就先被放到临时数组中
        while (i <= iEnd && j <= jEnd){
            if (nums[i] < nums[j]){
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        // 如果第一个数组指针已经全部放到临时数组中，那么将第二个数组的剩余元素也复制到临时数组
        if(i > iEnd){
            System.arraycopy(nums, j, temp, k, jEnd - j + 1);
        }
        if(j > jEnd){
            System.arraycopy(nums, i, temp, k, iEnd - i + 1);
        }
    }

（自下而上）

过程：假如要排序3， 9， 2， 7， 8， 5， 1， 4这个数组

首先将[3, 9],[2, 7], [8, 5], [1, 4]排序，排序完毕后将内容复制到nums数组，此时有序区间的长度为2

再将[3, 9, 2, 7],[8, 5, 1, 4]排序，排序完毕后将内容复制到nums数组，此时有序区间的长度为4

...

代码：

public static void merge(int[] nums, int i, int iEnd, int j, int jEnd, int[] temp){
        int k = i;
        // 如果两个数组的指针都未超出边界，则两个指针指向的元素进行比较，谁小就先被放到临时数组中
        while (i <= iEnd && j <= jEnd){
            if (nums[i] < nums[j]){
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        // 如果第一个数组指针已经全部放到临时数组中，那么将第二个数组的剩余元素也复制到临时数组
        if(i > iEnd){
            System.arraycopy(nums, j, temp, k, jEnd - j + 1);
        }
        if(j > jEnd){
            System.arraycopy(nums, i, temp, k, iEnd - i + 1);
        }
    }
    public void MergeSortBottomUp(int[] nums){
        int n = nums.length;
        int[] temp = new int[n];
        // width代表有序区间的长度，初始值width为1，因为一个数据默认有序
        for (int width = 1; width < n; width *= 2){
            // 找到左边界
            for (int left = 0; left < n; left += 2*width){
                // 再找右边界，且右边界必须保证不许超过n-1
                int right = Integer.min(left+2*width-1, n-1);
                int mid = Integer.min((left+right)>>1, n-1);
                merge(nums, left, mid, mid+1, right, temp);
            }
            //再将临时数组复制到nums
            System.arraycopy(temp, 0, nums, 0, n);
        }
    }

7). 快速排序

快排核心思想：每轮找到一个基准点，把比它小的放到它左边，比它大的放到右边，这样称为分区。

单边循环（lomuto分区）

要点：

• 选择最右侧元素作为基准点。
• j找比基准点小的，i找比基准点大的，一旦找到，二者进行交换。

交换时机：j找到小的，且与i不相等。

i找到>=基准点的元素后，不应该自增。

• 最后基准点与i交换，i即为基准点最终索引。

代码：

public void QuickSort(int[] nums) {
        quick(nums, 0, nums.length - 1);
    }
    private void quick(int[] nums, int left, int right) {
        if(left >= right) {
            return;
        }
        // p是基准点
        int p = Partition(nums, left, right);
        quick(nums, left, p - 1);
        quick(nums, p + 1, right);
    }
    private int Partition1(int[] nums, int left, int right) {
        // 选择最右侧的元素为基准点
        int pv = nums[right];
        // 两个指针从一侧开始
        int i = left;
        int j = left;
        while (j < right) {
            // j找到比找到比基准点小的了，没找到比它大的
            if(nums[j] < pv) {
                if(i != j){
                    swap(nums, i, j);
                }
                i++;
            }
            j++;
        }
        swap(nums, i, right);
        return i;
    }

双边循环

• 选择最左侧的元素作为基准点
• j找比基准点小的，i找比基准点大的，一旦找到，二者交换。

i从左向右，j从右向左。

• 最后基准点与i交换，i即为基准点最终索引。

代码：

private int Partition2(int[] nums, int left, int right) {
        int pv = nums[left];
        // i找小的，j找大的
        int i = left;
        int j = right;
        while (i < j) {
            // j此时比基准点大，而它要找到比基准点小的，所以继续循环
            while (i < j && nums[j] > pv){
                j--;
            }
            while(i < j && nums[i] <= pv){
                i++;
            }
            swap(nums, i, j);
        }
        swap(nums, i, left);
        return i;
    }

8). 计数排序

要点：

• 找到最大值，创建一个大小为 最大值+1 的数组
• count数组的索引对应原始数组的元素，用来统计该元素的出现次数
• 遍历count数组，根据count数组的索引（即原始数组的元素）以及出现的次数，生成排序后内容。因为count数组的索引是：已排序好的。

前提：待排序元素 >= 0（数组索引要求），且最大值不能太大。

代码：

public void CountingSort(int[] nums) {
        // 先找到数组的最大值
        int max = nums[0];
        for (int i : nums) {
            if (max < i) {
                max = i;
            }
        }
        int[] count = new int[max + 1];
        for (int i : nums) {
            // count[i]原始数组的元素
            count[i]++;
        }
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            // i表示原始数组元素，nums[i]表示原始数组元素出现的次数
            while (count[i] > 0){
                nums[k++] = i;
                count[i]--;
            }
        }
    }

改进的计数排序：

要点：

• 让原始数组的最小值映射到count[0]，最大值映射到count最右侧。
• 原始数组元素 - 最小值 = count索引。

由于未改进的计数排序是数值直接映射到数组的索引的，由于数组的索引不能是负数，那么数组中的元素要求不能有负数。我们可以改进。即将原始数组的最小值映射到count[0].

代码：

public void CountingSort(int[] nums) {
        // 先找到数组的最大值和最小值
        int max = nums[0];
        int min = nums[0];
        for (int i : nums) {
            if (max < i) {
                max = i;
            }
            if (min > i) {
                min = i;
            }
        }
        int[] count = new int[max - min + 1];
        for (int i : nums) {
            // i - min表示数组的索引，count[i - min]表示原始数组的元素的个数
            count[i - min]++;
        }
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0){
                // 将索引和值对应回去
                nums[k++] = min + i;
                count[i]--;
            }
        }
    }

9). 桶排序

想法是把数组中的元素放到一个一个桶中，根据某种运算计算得到桶的编号，然后从该桶中再查找目标值。

假设一个人的年龄是1到99岁，这里有一个元素是人年龄的数组nums : [2, 34, 56, 89, 99, 45, 23, 44];

我们可以根据某种运算（这个例子可以是元素值/10）得到桶的编号（比如0， 3， 5...），再将元素插入到桶中。（桶的个数是元素的个数）

代码：有点小问题，思路是对的。

public void BucketSort(int[] nums) {
        ArrayList<Integer>[] buckets = new ArrayList[10];
        // 1.准备桶
        for (int i = 0; i < nums.length; i++) {
            buckets[i] = new ArrayList<>();
        }
        // 2.向桶中添加元素
        for (int i : nums) {
            buckets[i / 10].add(i);
        }
        int j = 0;
        for (ArrayList<Integer> k : buckets) {
            // 下面代码有点小问题，toArray方法返回的是Object[]类型，转换会报错
            Integer[] arr = k.toArray();
            // 3.排序桶中的元素
            InsertSort(arr);
            // 4.依次把每个桶中的元素放入到原始数组中
            for (int element : arr) {
                nums[j++] = element;
            }
        }
    }