[数据结构与算法]算法与数据结构 - 排序详解

前言

点赞再看，养成习惯！

引言

在我们讲排序算法之前，我们首先要理解一个最基础的概念：什么是排序？ 排序其实很好理解，它其实就是将对象按照某种规律进行排列。这里面拥有两个关键元素：

1. 对象：我们排序的前提就是一定需要有可以供我们排序的对象，这个对象可以是数字，可以是文字，甚至可以是某种含有特定属性的对象映射。
2. 某种规律：比起叫某种规律，其实叫做排序依据更加贴切，我们在进行排序是需要有一种对象含有的客观属性按照某种规律进行排列。比如数字的由小到大，字符串长短的排列，亦或是字符串按照字典序进行排列等等，这些都是我们排序所必需的依据。

当我们简单的理解排序必须的元素之后，我们就可以着手进行今天的学习及挑战~

业务场景

相信考试是大多数小伙伴在学生时代绕不开的事情，而只要有考试难免的就会存在成绩排名，无论是按照学科排列还是总分排列。
假设下面这张表是三年一班某一次模拟考试的成绩单：

此时班主任王老师想要知道班里的总分排名,需要我们设计一个程序按照分数从高到低排列并导出表格给王老师，让我们想一想我们应该怎么做。

代码模拟

1. 冒泡排序

1.1 什么是冒泡排序

接下来我们要介绍第一种排序方法：冒泡排序 。什么是冒泡排序？

冒泡排序就是重复的进行从序列右边开始按照指定规则比较元素大小并根据比较结果交换两个元素位置的操作。在这个过程中，元素会像水中的水泡一样逐渐的从右侧浮动到序列的某一位置，因此这一算法才被称之为冒泡算法。

按照冒泡排序的定义我们来拆解步骤：

1. 从序列最右侧依次开始比较
2. 每次比较相邻元素的大小
3. 符合需求的元素转移到序列靠左位置继续比较

1.2 图解冒泡

按此步骤我们来测试下冒泡排序，比如我们此时有乱序的数字1 - 9，我们想要其按照从小到大的顺序进行排列

第一步我们先比较最右侧的两个元素大小：

以此类推：

当我们完成第一次遍历后，就可以获得此时序列中最小的元素，因此我们第二次遍历的目标就是队列中第二小的元素是什么（这也意味着我们此时无需再比较第一个元素的大小）。

依次类推：

这里我们观察到交换再第三次的时候就已经完成了排序，因此我们可以在此代码设计时也要考虑到提前完成的场景。

1.3 代码编写

我们再换回我们最初的问题，我们首先需要我们先将同学们的总分提取出来，形成一个数字数组：

int[] totalMarkArray = {280,231,236,150,297} ;

然后我们按照刚刚的步骤使用代码进行复现：

public class BubbleSort {
    public static void main(String[] args) {
        int[] totalMarkArray = {280, 231, 236, 150, 297};
        totalMarkArray = sort(totalMarkArray);
        Arrays.stream(totalMarkArray).forEach(item -> System.out.println(item));
    }

    private static int[] sort(int[] totalMarkArray) {
    // 设置提前退出标识
        Boolean flag = true;
        while (flag) {
            flag = false;
            // 从序列右侧开始遍历比较
            for (int i = totalMarkArray.length - 1; i > 0; i--) {
                if (totalMarkArray[i] < totalMarkArray[i - 1]) {
                // 符合交换条件 进行交换
                    flag = true;
                    totalMarkArray[i - 1] += totalMarkArray[i];
                    totalMarkArray[i] = totalMarkArray[i - 1] - totalMarkArray[i];
                    totalMarkArray[i - 1] -= totalMarkArray[i];
                }
            }
        }
        return totalMarkArray;
    }
}

运行结果：

1.4 总结分析

时间复杂度

在冒泡排序中,第一轮需要比较n-1次,第二轮需要比较n-2次,以此类推最后一轮仅需要比较1次,总的比较次数应该为(n-1)+(n-2)+...+1 ≈ n^2 /2 ,当然并不排除原有序列本身就是有序的,因此仅需一次便可完成排序,因此冒泡排序时间复杂度为:
最优: O(n)
最差: O(n^2)

是否为原地排序

冒泡排序无需开辟新的内存空间,空间复杂度为O(1),因此属于原地排序

2. 选择排序

2.1 什么是选择排序

什么是选择排序?

选择排序就是重复的从待排序的数字中寻找最小值(或最大值)并将其与队列最左侧的数字进行交换,找到后依次寻找下一符合要求的元素值并交换。

我们通过概念拆解出选择排序最关键的步骤：

1. 寻找符合要求的元素（此时队列的最小值或者最大值）
2. 与序列头交换

2.2 图解选择排序

还是老规律，我们先提供一个乱序的1-9序列：

接下来我们遍历数组，获取此时数组中的最大值：

第二步：交换元素位置

以此类推，我们将剩下的元素完成排序：

到此我们就完成了一次选择排序

2.3 代码编写

我们还是以引言中的学科总分从大到小排序为例:

int[] totalMarkArray = {280,231,236,150,297} ;

针对这个数组我们将要用代码完成依次从待选队列中获取最大值并将其放置到队列左侧:

public class ChooseSort {
    public static void main(String[] args) {
        int[] totalMarkArray = {280, 231, 236, 150, 297};
        totalMarkArray = sort(totalMarkArray);
        Arrays.stream(totalMarkArray).forEach(item -> System.out.println(item));
    }

    private static int[] sort(int[] totalMarkArray) {
        for (int i = 0; i < totalMarkArray.length - 1; i++) {
            // 记录最大值索引位置(坐标)
            Integer index = i;
            // 比较
            for (int j = i + 1; j < totalMarkArray.length; j++) {
                if (totalMarkArray[index] < totalMarkArray[j]) {
                    index = j;
                }
            }
            // 判断是否需要交换
            if (index != i) {
                totalMarkArray[index] += totalMarkArray[i];
                totalMarkArray[i] = totalMarkArray[index] - totalMarkArray[i];
                totalMarkArray[index] -= totalMarkArray[i];
            }
        }
        return totalMarkArray;
    }

}

运行结果:

2.4 总结分析

时间复杂度

选择排序使用了线性查找来寻找最小值,第一次查找需要(n-1)次,第二次需要(n-2)次,依次类推完成排序需要n^2/2次。由于无法再遍历完成前提前退出，因此其最优复杂度与最差复杂度相同，均为O（n^2）

是否为原地排序

由于不需要额外的内存空间，因此属于原地排序

3. 插入排序

3.1 什么是插入排序

插入排序是一种从序列左端开始依次对数据进行排序的算法。在排序过程中，左侧的数据陆续归位，而右侧留下的就是还未被排序的数据，插入排序的思路就是从右侧的未排序的数据中取出待排序元素然后依次与已排序数据进行比较并将其插入合适的位置上。

这里我们还是提取关键步骤：

1. 需要将序列分成两部分，分别是已排序区域与未排序区域
2. 依次将未排序区域中的元素与已排序区域中的元素进行比较并将其插入到适当的位置

3.1 图解插入排序

我们还是针对数字1-9进行排序：

接下来我们重复进行将未排序区域的元素插入到已排序区域中：

我们继续，直到排序完成：

3.3 代码编写

我们还是以引言中的学科总分从大到小排序为例:

int[] totalMarkArray = {280,231,236,150,297} ;

针对这个数组我们将要用代码完成依次从未排序区域获取元素与已排序区域进行比较插入的过程。

public class InsertSort {

    public static void main(String[] args) {
        int[] totalMarkArray = {280, 231, 236, 150, 297};
        totalMarkArray = sort(totalMarkArray);
        Arrays.stream(totalMarkArray).forEach(item -> System.out.println(item));
    }

    private static int[] sort(int[] totalMarkArray) {
        for (int i = 0; i < totalMarkArray.length; i++) {
            int template = totalMarkArray[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                // 比上一元素小就将该元素右移
                if (template < totalMarkArray[j]) {
                    totalMarkArray[j + 1] = totalMarkArray[j];
                } else {
                    break;
                }
            }
            // 将元素插入到指定位置
            totalMarkArray[j + 1] = template;
        }
        return totalMarkArray;
    }
}

运行结果：

3.4 总结分析

时间复杂度

在插入排序中,需要将数据取出与左侧数据进行比较,如果左侧数字更小则停止比较。按照最坏的情况想，第n次排序需要查找（n-1）次,我们一共需要进行n× (n-1)次排序,时间复杂度为O(n^2) ;

空间复杂度

不需要额外内存空间,属于原地排序,内存复杂度为O(1) ;

4. 堆排序

4.1 什么是堆排序