数据结构与算法 排序算法(一) 附有详细动画流程分析图

数据结构与算法 排序算法(一)

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 的排序

如何进行负数排序:

可以先将负数通过绝对值转变成正数, 然后排序完成之后,在转变成对应位置的负数, 因为这个需求很少见,我这里就没研究了,这是我的一点思路,可以参考一下 😊

完整代码

原创不易,您的点赞就是对我最大的支持!