算法笔记 - 排序基础

最新推荐文章于 2024-09-25 10:59:43 发布

Gardel

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量117

点赞数

文章标签： java 算法排序算法

本文链接：https://blog.csdn.net/baidu_24285051/article/details/108794459

版权

文章目录

简单排序

简单排序

程序中的数据千变万化，但通常情况下我们需要这些数据按照一定的顺序排列，这样方便人的阅读或者便于查找。

现实生活中我们排列一些东西（例如扑克牌），会有很多种办法：可以依次在牌堆里找出最小的牌，放到另一堆中；也可以将牌分组，每一组排序后再依次从每组中找出合适的牌放到另一个地方……

在算法的世界中也有各种排序的办法，下面是一些基础的算法。（以下均基于定长连续数组，假定目的是按照升序排列元素）

冒泡排序

冒泡排序是一种基于交换的排序，它的基本思想是：两两比较相邻记录的值，如果后者小于前者则交换，直到不存在反序的记录为止。

轨迹

索引	0	1	2	3	4	5	6	7	8	9
第一轮	9	8	7	6	5	4	3	2	1	0
	8	9	7	6	5	4	3	2	1	0
	8	7	9	6	5	4	3	2	1	0
	8	7	6	9	5	4	3	2	1	0
	8	7	6	5	9	4	3	2	1	0
	8	7	6	5	4	9	3	2	1	0
	8	7	6	5	4	3	9	2	1	0
	8	7	6	5	4	3	2	9	1	0
	8	7	6	5	4	3	2	1	9	0
	8	7	6	5	4	3	2	1	0	9
第二轮	8	7	6	5	4	3	2	1	0	9
	7	8	6	5	4	3	2	1	0	9
	7	6	8	5	4	3	2	1	0	9
	7	6	5	8	4	3	2	1	0	9
	7	6	5	4	8	3	2	1	0	9
	7	6	5	4	3	8	2	1	0	9
	7	6	5	4	3	2	8	1	0	9
	7	6	5	4	3	2	1	8	0	9
	7	6	5	4	3	2	1	0	8	9
…	.	.	.	.	.	.	.	.	.	.
第九轮	1	0	2	3	4	5	6	7	8	9
	0	1	2	3	4	5	6	7	8	9
结果	0	1	2	3	4	5	6	7	8	9

可以看到，每一个大的数字像水底的泡泡一样咕噜噜冒到了最上面。虽然算法思路比较直观，但是计算机操作起来还是比较复杂。

代码

/**
 * 最低 JDK 版本：1.8，下同
 */
import java.util.Arrays;

public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        int t; // 用于交换暂存
        for (int i = 0; i < arr.length; i++) {
            // 一个长度为 N 的数组最多有 N * (N - 1) / 2 个逆序
            // 因此内部循环不需要将数组全部搜索
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j + 1] < arr[j]) {
                    t = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = t;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] testArr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; // 测试用例
        bubbleSort(testArr);
        System.out.println(Arrays.toString(testArr));
    }
}

选择排序

选择排序的步骤如下：
首先在整个数组中找到最小的元素，将它与数列起始位置的元素互换位置，随后再从剩下的元素中继续寻找最小的元素，放到已排列序列的末尾。以此类推，直到所有元素均排列完毕。

轨迹

索引	0	1	2	3	4	5	6	7	8	9
比较	9	8	7	6	5	4	3	2	1	0
交换	0	8	7	6	5	4	3	2	1	9
比较	0	8	7	6	5	4	3	2	1	9
交换	0	1	7	6	5	4	3	2	8	9
比较	0	1	7	6	5	4	3	2	8	9
交换	0	1	2	6	5	4	3	7	8	9
比较	0	1	2	6	5	4	3	7	8	9
交换	0	1	2	3	5	4	6	7	8	9
比较	0	1	2	3	5	4	6	7	8	9
交换	0	1	2	3	4	5	6	7	8	9
比较	0	1	2	3	4	5	6	7	8	9
比较	0	1	2	3	4	5	6	7	8	9
比较	0	1	2	3	4	5	6	7	8	9
比较	0	1	2	3	4	5	6	7	8	9
比较	0	1	2	3	4	5	6	7	8	9
结果	0	1	2	3	4	5	6	7	8	9

选择排序比冒泡排序少了一些交换，但是却有很多的比较。

代码

import java.util.Arrays;

public class SelectionSort {

    public static void selectionSort(int[] arr) {
        int N = arr.length;
        int t; // 用于交换暂存
        for (int i = 0; i < N; i++) { // 将a[i]和a[i+1..N]中最小的元素交换
            int min = i; // 最小元素的索引
            for (int j = i + 1; j < N; j++)
                if (arr[j] < arr[min]) min = j;
            if (min != i) { // 交换
                t = arr[i];
                arr[i] = arr[min];
                arr[min] = t;
            }
        }
    }

    public static void main(String[] args) {
        int[] testArr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; // 测试用例
        selectionSort(testArr);
        System.out.println(Arrays.toString(testArr));
    }
}

插入排序

插入排序的基本思想是：将每一个元素插入到其他已经有序的排列中的适当位置。
在计算机的实现中，为了给要插入的元素腾出空间，我们需要将其余所有元素在插入之前都向右移动一位。

轨迹

索引	0	1	2	3	4	5	6	7	8	9
i=0	9	8	7	6	5	4	3	2	1	0
i=1	8	9	7	6	5	4	3	2	1	0
i=2	8	7	9	6	5	4	3	2	1	0
	7	8	9	6	5	4	3	2	1	0
i=3	7	8	6	9	5	4	3	2	1	0
	7	6	8	9	5	4	3	2	1	0
	6	7	8	9	5	4	3	2	1	0
i=4	6	7	8	5	9	4	3	2	1	0
	6	7	5	8	9	4	3	2	1	0
	6	5	7	8	9	4	3	2	1	0
	5	6	7	8	9	4	3	2	1	0
…	.	.	.	.	.	.	.	.	.	.
i=9	1	2	3	4	5	6	7	8	0	9
	1	2	3	4	5	6	7	0	8	9
	1	2	3	4	5	6	0	7	8	9
	1	2	3	4	5	0	6	7	8	9
	1	2	3	4	0	5	6	7	8	9
	1	2	3	0	4	5	6	7	8	9
	1	2	0	3	4	5	6	7	8	9
	1	0	2	3	4	5	6	7	8	9
	0	1	2	3	4	5	6	7	8	9
结果	0	1	2	3	4	5	6	7	8	9

是的，看完之后有种似曾相识的感觉，就像是把冒泡排序倒着来了一遍。没错，两种算法的步骤是一致的，只是根据不同的角度看名字不同了而已，有没有觉得很神奇？

代码

import java.util.Arrays;

public class InsertionSort {

    public static void insertionSort(int[] arr) {
        int N = arr.length;
        int t; // 用于交换暂存
        for (int i = 1; i < N; i++) {
            // 将 a[i] 插入到 a[i-1]、a[i-2]、a[i-3]...之中
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                // 如果当前元素小于前一个元素，则交换二者
                t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
            }
        }
    }

    public static void main(String[] args) {
        int[] testArr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; // 测试用例
        insertionSort(testArr);
        System.out.println(Arrays.toString(testArr));
    }
}

希尔排序

希尔排序的思想是：使长度为 N 的数组中任意间隔为 h (h ≧ 1 且 h < N - 1) 的元素都是有序的。
为了达到这个目的，我们可以先指定一个合适的 h，用插入排序将数组中所有间隔为 h 的元素排序，h - 1 后再次排序，直到任意相邻两个元素都是有序的。
这里在实现 h 有序时不使用选择排序的原因是：在 h = 1 时选择排序不能利用现有的次序来降低时间复杂度，它仍然会查找整个数组、互换最小的元素。

轨迹

设 N = 10; h = 4, 1

索引	0	1	2	3	4	5	6	7	8	9
起始	9	8	7	6	5	4	3	2	1	0
h=4	5	8	7	6	9	4	3	2	1	0
	5	4	7	6	9	8	3	2	1	0
	5	4	3	6	9	8	7	2	1	0
	5	4	3	2	9	8	7	6	1	0
	5	4	3	2	1	8	7	6	9	0
	1	4	3	2	5	8	7	6	9	0
	1	4	3	2	5	0	7	6	9	8
	1	0	3	2	5	4	7	6	9	8
h=1	0	1	3	2	5	4	7	6	9	8
	0	1	2	3	5	4	7	6	9	8
	0	1	2	3	4	5	7	6	9	8
	0	1	2	3	4	5	6	7	9	8
	0	1	2	3	4	5	6	7	8	9

在 h = 4 的情况下彻底排序后我们可以观察到，下一步选择 h = 1 时即可一次性把所有元素排列代价最小。但是如何选择这个 h 仍是一个很难的问题，在《算法》一书中作者给出了这么一个公式： $h=\dfrac{3^k-1}{2}$ ，正常情况下就足够使用了。
希尔排序的优势在于它可以让一个元素一次性地朝最终位置前进一大步，然后算法再取越来越小的步长进行排序。算法的最后一步就是普通的插入排序，但是到了这一步，需要排序的数据几乎已经排好了。

代码

import java.util.Arrays;

public class ShellSort {

    public static void shellSort(int[] arr) {
        int N = arr.length;
        int h = 1;
        int t;
        while (h < N / 3) h = 3 * h + 1;
        while (h >= 1) {
            // 将数组变为 h 有序
            for (int i = h; i < N; i++) {
                // 将 a[i] 插入到 a[i-h], a[i-2*h], a[i-3*h]... 之中
                // 此处是一个插入排序，但跨度从 1 变成了 h
                for (int j = i; j >= h && arr[j] < arr[j - h]; j -= h) {
                    t = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = t;
                }
            }
            h = h / 3;
        }
    }

    public static void main(String[] args) {
        int[] testArr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; // 测试用例
        shellSort(testArr);
        System.out.println(Arrays.toString(testArr));
    }
}