数据结构与算法 排序算法 附有详细动画流程分析图
Posted android超级兵
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构与算法 排序算法 附有详细动画流程分析图相关的知识,希望对你有一定的参考价值。
数据结构与算法 排序算法(一)
Tips: 采用java语言, 关注博主,底部附有完整代码,
本篇介绍排序算法:
- 冒泡排序
- 选择排序
- 插入排序
- 基数排序
排序算法对比
算法名称 | 10万次测试 | 效果图 |
---|---|---|
冒泡排序 | 10万次 / 20秒 | |
选择排序 | 10万次 / 3秒 | |
插入排序 | 10万次 / 800毫秒 | |
基数排序 | 10万次 / 22毫秒 |
冒泡排序
冒泡排序应该是最常见,最简单的排序算法了!
要想学会冒泡排序,只需要记住 2 个重点
- 找出最大值
- 交换位置
即可
找出最大值
int[] ints = new int[]21, 4, 16, 1, 20;
int maxValue = 0;
for (int i = 0; i < ints.length; i++)
if (maxValue <= ints[i])
maxValue = ints[i];
System.out.println("最大值为:" + maxValue);
这段代码很简单, 初学者也能看懂!
交换位置
如果想让A桶和 B桶 内的水交换, 那么就必须借助C 桶
先将A桶的水倒入C桶, 再将 B桶的水倒入A桶, 最后将C 桶的水 倒入B桶中…
例如这样:
那么用代码写就应该是这样:
int a = 10;
int b = 20;
int c = 0;
System.out.printf("原始数据:a = %d \\t b = %d\\n", a, b);
c = a;
a = b;
b = c;
System.out.printf("交换后:a = %d \\t b = %d\\n", a, b);
那么 如何将最大值移动到数组最后一位呢?
现在已经确保了最后一位是最大的元素
那么只需要找ints.length - 2 中最大的元素 交换到最后一位即可
// 倒数第二个位置
for (int i = 0; i < ints.length - 1 - 1; i++)
// 交换
if (ints[i] > ints[i + 1])
int temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
System.out.println("第二次移动后:" + Arrays.toString(ints));
那么按照这个节奏,依次代码排序为:
System.out.println("原始数据:" + Arrays.toString(ints));
for (int i = 0; i < ints.length - 1; i++)
// 当前元素 和 下一个元素相比较
// 如果当前元素 > 下一个元素就交换
if (ints[i] > ints[i + 1])
int temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
System.out.println("第一次移动后:" + Arrays.toString(ints));
// 倒数第二个位置
for (int i = 0; i < ints.length - 1 - 1; i++)
// 交换
if (ints[i] > ints[i + 1])
int temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
System.out.println("第二次移动后:" + Arrays.toString(ints));
// 倒数第三个位置
for (int i = 0; i < ints.length - 1 - 2; i++)
// 交换
if (ints[i] > ints[i + 1])
int temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
System.out.println("第三次移动后:" + Arrays.toString(ints));
// 倒数第四个位置
for (int i = 0; i < ints.length - 1 - 3; i++)
// 交换
if (ints[i] > ints[i + 1])
int temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
System.out.println("第四次移动后:" + Arrays.toString(ints));
运行结果:
原始数据:[21, 4, 16, 1, 20]
第一次移动后:[4, 16, 1, 20, 21]
第二次移动后:[4, 1, 16, 20, 21]
第三次移动后:[1, 4, 16, 20, 21]
第四次移动后:[1, 4, 16, 20, 21]
可以看出,有很多很多重复的数据,那么通过一个for循环来优化一下:
完整代码
for (int j = 0; j < ints.length - 1; j++)
for (int i = 0; i < ints.length - 1 - j; i++)
// 交换
if (ints[i] > ints[i + 1])
temp = ints[i];
ints[i] = ints[i + 1];
ints[i + 1] = temp;
辅助动画流程图:
优缺点分析
优点:
- 能够实现排序
- 简单,入门初学者福音
缺点:
- 数据量过大时,频繁交换会导致排序时间过长 10万次排序用时20秒左右
选择排序
要想学会选择排序,还是只需要记住 2 个重点
- 找出最小值
- 交换
选择排序
和冒泡排序
有异曲同工之妙
冒泡排序
是循环的时候,边交换位置,边排序选择排序
是先找到最小值然后在交换,省去了大量的交换操作!
完整代码
public static void methodSort2(int[] ints)
System.out.println("原始数据为:" + Arrays.toString(ints));
for (int i = 0; i < ints.length - 1; i++)
// 记录最小值下标
int minIndex = i;
// 记录最小值
int minValue = ints[i];
for (int j = i; j < ints.length; j++)
if (minValue > ints[j])
minValue = ints[j];
minIndex = j;
System.out.println("当前最小值为:" + minValue);
// 交换
int temp = ints[i];
ints[i] = ints[minIndex];
ints[minIndex] = temp;
System.out.println("排序完成:" + Arrays.toString(ints));
打印数据:
选择排序:
原始数据为:[12, 4, 16, 1, 20, 21, 5, 8, 10, 3]
当前最小值为:21
当前最小值为:20
当前最小值为:16
当前最小值为:12
当前最小值为:10
当前最小值为:8
当前最小值为:5
当前最小值为:4
当前最小值为:3
排序完成:[21, 20, 16, 12, 10, 8, 5, 4, 3, 1]
辅助动画流程图:
优缺点分析
优点:
- 比冒泡排序更省事,代码简单
- 避免了过多的交换位置操作
缺点:
- 无脑循环每一个值,数据量过多的情况下,还是会耗时很久 10w个数据 用时:3.214秒
插入排序
重点:
-
倒叙输出数据
-
默认之前数据全部是有序的
-
从下标1的位置开始,始终和前面的数据相比较, 如果当前数据比上一个数据小,就让上一个数据后移,直到上一个数据 小于当前数据
倒叙输出数据
这段代码很简单, 一看就懂了!
当前原始数据为: [12, 4, 16, 1, 20, 21, 5, 8, 10, 3]
那么如果想获取下标 5之前的倒叙数据,直接这样就可以
完整代码
# 插入排序
public static void method2(int[] ints)
for (int i = 1; i < ints.length; i++)
// 如果当前元素 < 上一个元素
if (ints[i] < ints[i - 1])
// 当前数据
int currentValue = ints[i];
int j;
// 倒叙 每一个元素
// ints[j] 倒叙后的每一个元素
for (j = i - 1; j >= 0 && currentValue < ints[j]; j--)
// 元素后移 给需要插入的元素腾位置
ints[j + 1] = ints[j];
// 需要插入的元素 = currentValue
ints[j + 1] = currentValue;
动画流程图:
优缺点分析
优点:
- 效率明显提高 10万个数据 用时:871毫秒
- 代码逻辑清晰
缺点:
- 如果遇到 [1,5,7,8,9,2], 这种情况 数字比较小的数在后方的情况,还是会出现大量不必要的排序
基数排序
重点:
-
数组中的最大值,是几位数
-
获取数组中每个数字 每一位的值
-
队列
基本原理:
创建10个队列,用来存放不同位置的数据
依次根据个位 ,十位, 百位,千位… 的顺序依次放入对应的队列中
假设当前数是 632
目前根据个位排列,那么就放入到第二个队列中, 假设根据百位来排列,那么就放入到第六个队列中
最终排列完个位,就把数据依次替换为存入队列中的数据(从队列0至 队列9)
依次重复操作, 排序次数是数组中的最大值,是几位数那么就排列几次, 假设当前最大值是 6421 ,那么就排列4次,因为6421是4位数
一张图搞懂:
数组中的最大值,是几位数
这段代码很好理解, 这里获取几位数的时候,用到一个小技巧, 先将int转换成string,然后 获取string 的 length即可
获取数组中每个数字 每一位的值
那么就以最大值来举例
另外一种获取每一位的办法
队列
队列很简单,只需要知道他的特性是先进先出原则即可
在这里我才用的是自己写的用数组模拟队列, 队列的代码比较简单,就不贴代码了,如果需要请下载完整代码
完整代码
public static void sort2(int[] ints)
System.out.println("元素数据为:" + Arrays.toString(ints));
// 找出最大值
int max = 0;
for (int element : ints)
if (element >= max)
max = element;
// 判断最大值是几位数
int maxLength = String.valueOf(max).length();
System.out.println("最大值为:" + max + "是" + maxLength + "位数");
ArrayQueue[] queues = new ArrayQueue[10];
// 创建对应队列
for (int i = 0; i < queues.length; i++)
queues[i] = new ArrayQueue(10);
for (int i = 0, n = 1; i < maxLength; i++, n *= 10)
// 循环每一个值
for (int j = 0; j < ints.length; j++)
// 求出个位 十位 百位
int value = ints[j] / n % 10;
// 放入到队列中
queues[value].addQueue(ints[j]);
// 将桶中的数据在重新赋值到 ints[] 中
int index = 0;
for (int j = 0; j < queues.length; j++)
for (int k = 0; k < queues[j].size(); k++)
try
if (queues[j].headQueue() != 0)
ints[index++] = queues[j].getQueue();
catch (Exception e)
辅助图:
优缺点分析
优点:
- 大大的节省了时间, 10万个数据用时22毫秒
缺点:
- 需要占用额外空间创建10个队列
- 代码开始变得稍微复杂
- 此段代码无法进行负数 和 0 的排序
如何进行负数排序:
可以先将负数通过绝对值转变成正数, 然后排序完成之后,在转变成对应位置的负数, 因为这个需求很少见,我这里就没研究了,这是我的一点思路,可以参考一下 😊
原创不易,您的点赞就是对我最大的支持!
以上是关于数据结构与算法 排序算法 附有详细动画流程分析图的主要内容,如果未能解决你的问题,请参考以下文章