【数据结构与算法】第三章：简单排序

return “Student{” +

“userName='” + userName + ‘’’ +

“, age=” + age +

‘}’;

}

@Override

public int compareTo(Student o) {

return this.getAge() - o.getAge();

}

}

Student{userName=‘李四’, age=20}

3.2、冒泡排序

---

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法

案例：

• 需求： 排序前：{4,5,6,3,2,1} 排序后：{1,2,3,4,5,6}

• 排序原理

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置

2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值

• API设计

• 代码实现

public class BubbleSort {

/**

• 比较次数

*/

private static int n1 = 0;

/**

• 交换次数

*/

private static int n2 = 0;

public static void main(String[] args) {

Integer[] c = {4, 5, 6, 3, 2, 1};

System.out.println(“排序前：” + Arrays.toString©);

sort©;

System.out.println(“排序后：” + Arrays.toString©);

System.out.println(“比较次数：” + n1);

System.out.println(“交换次数：” + n2);

}

/**

• 排序

• @param c

*/

public static void sort(Comparable[] a) {

// 数组长度

int n = a.length;

// 需要比较的总趟数(冒泡次数): n-1

for (int i = n - 1; i > 0; i–) {

System.out.print(“【第” + (n - i) + “趟】”);

int x = 0;

int y = 0;

// 单趟比较次数: i

// j从1开始，一直到i

// 用j前面的元素和j处的元素比较

for (int j = 1; j <= i; j++) {

x++;

// 比较并交换

if (greater(a[j-1], a[j])) {

y++;

exch(a, j-1, j);

}

}

System.out.print(“比较：” + x + “次”);

System.out.print(" 交换：" + y + “次”);

System.out.println();

}

}

/**

• 比较 c1 是否大于 c2

• @param c1

• @param c2

• @return

*/

private static boolean greater(Comparable c1, Comparable c2) {

return c1.compareTo(c2) > 0;

}

/**

• 交换数组c中位置i和j处的元素

• @param c 目标数组

• @param i 交换索引

• @param j 交换索引

*/

private static void exch(Comparable[] c, int i, int j) {

if (c[i] != c[j]) {

Comparable temp = c[i];

c[i] = c[j];

c[j] = temp;

}

}

}

排序前：[6, 3, 5, 4, 2, 1]

【第1趟】比较：5次 交换：5次

【第2趟】比较：4次 交换：3次

【第3趟】比较：3次 交换：2次

【第4趟】比较：2次 交换：2次

【第5趟】比较：1次 交换：1次

排序后：[1, 2, 3, 4, 5, 6]

比较次数：15

交换次数：13

• 时间复杂度分析

• 冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

• 在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：元素比较的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2

元素交换的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2

总执行次数为：

(N^2 /2 -N/2) + (N^2 /2-N/2) = N^2-N

• 按照大O推导法则，保留函数中的最高阶项，那么最终冒泡排序的时间复杂度为： O(N^2) (平方阶)

3.3、选择排序

---

选择排序是一种更加简单直观的排序方法

案例：

• 需求： 排序前：{4,6,8,7,9,2,10,1} 排序后：{1,2,4,5,7,8,9,10}

• 排序原理

1. 每一次遍历的过程中，都假定第一个索引处的元素是最 小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出 的值为最小值，最后可以找到最小值所在的索引

2. 交换第一个索引处和最小值所在的索引处的值

• API设计

• 代码实现

public class SelectionSort {

public static void main(String[] args) {

Integer[] c = {4,6,8,7,9,2,10,1};

System.out.println(“排序前：” + Arrays.toString©);

sort©;

System.out.println(“排序后：” + Arrays.toString©);

}

/**

• 排序

• @param c

*/

public static void sort(Comparable[] c) {

// 最小元素所在位置

int minIndex;

// 选择趟数

for (int i = 0; i < c.length - 1; i++) {

// 定义一个变量，记录最小元素所在的素引；默认为参与排序的第一个元素的所在索引

minindex = i;

// 每一趟中的比较次数，找出这一趟中参与排序的最小元素j

for (int j = i + 1; j < c.length; j++) {

// 比较minindex与j位置的值

if (greater(c[minindex], c[j])) {

minindex = j;

}

}

// 交换索引位置为i、minindex的值

if(minindex != i){

exch(c, i, minindex);

}

}

}

/**

• 比较 c1 是否大于 c2

• @param c1

• @param c2

• @return

*/

private static boolean greater(Comparable c1, Comparable c2) {

return c1.compareTo(c2) > 0;

}

/**

• 交换数组c中位置i和j处的元素

• @param c 目标数组

• @param i 交换索引

• @param j 交换索引

*/

private static void exch(Comparable[] c, int i, int j) {

if (c[i] != c[j]) {

Comparable temp = c[i];

c[i] = c[j];

c[j] = temp;

}

}

}

排序前：[4, 6, 8, 7, 9, 2, 10, 1]

排序后：[1, 2, 4, 6, 7, 8, 9, 10]

• 时间复杂度分析

• 选择排序使用了 双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数：

数据比较次数：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2 /2 - N/2;

数据交换次数：

N-1

时间复杂度：N^2 /2 - N/2+（N-1）=N^2 /2 + N/2 - 1

• 根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为：O(N^2) （平方阶）

3.4、插入排序

---

插入排序（Insertion sort）是一种简单直观且 稳定的 排序算法

插入排序的工作方式非常像人们排序一手扑克牌一样。

开始时，我们的左手为空并且桌子上的牌面朝下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较，如下图所示：

案例：

• 需求: 排序前：{4,3,2,10,12,1,5,6} 排序后：{1,2,3,4,5,6,10,12}

• 排序原理：

1. 把所有的元素分为两组，已经排序的和未排序的

2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入

3. 倒序遍历已经排序的元素，依次和待插入的元素进行比较， 直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位

• API设计

• 代码实现

public class InsertionSort {

public static void main(String[] args) {

Integer[] c = {4,3,2,10,12,1,5,6};

System.out.println(“排序前：” + Arrays.toString©);

sort©;

System.out.println(“排序后：” + Arrays.toString©);

}

/**

• 排序

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

其他的内容都可以按照路线图里面整理出来的知识点逐一去熟悉，学习，消化，不建议你去看书学习，最好是多看一些视频，把不懂地方反复看，学习了一节视频内容第二天一定要去复习，并总结成思维导图，形成树状知识网络结构，方便日后复习。

这里还有一份很不错的《Java基础核心总结笔记》，特意跟大家分享出来

目录：

部分内容截图：

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

其他的内容都可以按照路线图里面整理出来的知识点逐一去熟悉，学习，消化，不建议你去看书学习，最好是多看一些视频，把不懂地方反复看，学习了一节视频内容第二天一定要去复习，并总结成思维导图，形成树状知识网络结构，方便日后复习。

这里还有一份很不错的《Java基础核心总结笔记》，特意跟大家分享出来

目录：

[外链图片转存中…(img-ogcVg5qq-1713549824031)]

部分内容截图：

[外链图片转存中…(img-Qm45kxPp-1713549824031)]

[外链图片转存中…(img-ZZ1MFG29-1713549824032)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！