蓝桥杯备考随手记: 常用的三种排序算法(冒泡排序、插入排序、选择排序)

1. 冒泡排序(Bubble Sort)

冒泡排序是一种简单直观的排序算法,在待排序序列中不断地交换相邻两个元素的位置,通过多次遍历,将最大(或最小)的元素逐渐向右(或左)移动到正确的位置,直到整个序列有序。

冒泡排序的基本思想如下:

  1. 从序列的第一个元素开始,比较相邻两个元素的大小。
  2. 如果前一个元素大于后一个元素,则交换它们的位置,将较大的元素向右移动。
  3. 继续比较下一个相邻的元素,重复上述步骤,直到遍历到序列的最后一个元素。
  4. 重复以上步骤,直至整个序列有序。

给定数组 A=[64,34,25,12,22,11,90],冒泡排序的过程如下:

  1. 第一轮:

    • 比较 64 和 34 ,交换位置,数组变为 [34,64,25,12,22,11,90]。
    • 继续比较 64 和 25 ,交换位置,数组变为 [34,25,64,12,22,11,90]。
    • 继续比较 64 和 12 ,交换位置,数组变为 [34,25,12,64,22,11,90]。
    • 继续比较 64 和 22,交换位置,数组变为 [34,25,12,22,64,11,90]。
    • 继续比较 64 和 11,交换位置,数组变为 [34,25,12,22,11,64,90]。
    • 最后比较 64 和 90,不交换位置。
    • 第一轮结束,最大值 90 已经排在最后。
  2. 第二轮:

    • 比较 34 和 25 ,交换位置,数组变为 [25,34,12,22,11,64,90]。
    • 继续比较 34 和 12,交换位置,数组变为 [25,12,34,22,11,64,90]。
    • 继续比较 34 和 22,交换位置,数组变为 [25,12,22,34,11,64,90]。
    • 继续比较 34 和 11,交换位置,数组变为 [25,12,22,11,34,64,90]。
    • 最后比较 34 和 64,不交换位置。
    • 第二轮结束。
  3. 依此类推,直到数组完全排序。

冒泡排序的时间复杂度为O(n^2),其中n表示待排序序列的长度。冒泡排序是稳定的,因为相同元素的相对顺序不会发生改变。

2. 插入排序(Insertion Sort)

插入排序是一种简单且直观的排序算法,将待排序序列分为已排序和未排序两部分,每次从未排序的部分中取出一个元素插入到已排序的正确位置,直到整个序列有序。

插入排序的基本思想如下:

  1. 从待排序序列中选择一个元素,将其插入到已排序序列的合适位置上。
  2. 从已排序序列的末尾开始,将比当前元素大的元素向右移动,腾出插入位置。
  3. 将当前元素插入到合适的位置上,使已排序序列依然有序。
  4. 重复以上步骤,直到未排序序列中的所有元素都插入到已排序序列中。

给定数组 A=[64,34,25,12,22,11,90],插入排序的过程如下:

  1. 第一轮:
    • 将第二个元素 34 插入到已排序子数组 [64] 的合适位置,数组变为 [34,64,25,12,22,11,90]。
  2. 第二轮:
    • 将第三个元素 25 插入到已排序子数组 [34,64] 的合适位置,数组变为 [25,34,64,12,22,11,90]。
  3. 依此类推,直到数组完全排序。

插入排序的时间复杂度为O(n^2),其中n表示待排序序列的长度。插入排序是稳定的,因为相同元素的相对顺序不会发生改变。

3. 选择排序(Selection Sort)

选择排序是一种简单直观的排序算法,每次从待排序序列中选择最小(或最大)的元素,放到已排序序列的末尾,直到整个序列有序。

选择排序的基本思想如下:

  1. 将待排序序列分为已排序和未排序两部分,初始时已排序序列为空。
  2. 从未排序序列中选择最小(或最大)的元素,将其与未排序序列的第一个元素交换位置,即将最小(或最大)的元素放到已排序序列的末尾。
  3. 将已排序序列的末尾后移一位,将未排序序列缩小一个元素。
  4. 重复以上步骤,直到未排序序列中的所有元素都被加入到已排序序列中。

给定数组 A=[64,34,25,12,22,11,90],选择排序的过程如下:

  1. 第一轮:
    • 从数组中选择最小值 11,与第一个元素 64 交换位置,数组变为 [11,34,25,12,22,64,90]。
  2. 第二轮:
    • 从第二个元素开始的子数组中选择最小值 12,与第二个元素 34 交换位置,数组变为 [11,12,25,34,22,64,90]。
  3. 依此类推,直到数组完全排序。

选择排序的时间复杂度为O(n^2),其中n表示待排序序列的长度。选择排序是不稳定的,因为相同元素的相对顺序可能会发生改变。

4. 使用 Java 代码实现

  1. 冒泡排序 :

    java 复制代码
    public class BubbleSort {
        // 冒泡排序方法
        public static void bubbleSort(int[] arr) {
            int n = arr.length;
            // 外层循环控制比较轮数
            for (int i = 0; i < n - 1; i++) {
                // 内层循环执行相邻元素比较并交换
                for (int j = 0; j < n - i - 1; j++) {
                    // 如果前一个元素大于后一个元素,则交换它们
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {64, 34, 25, 12, 22, 11, 90};
            // 调用冒泡排序方法对数组进行排序
            bubbleSort(arr);
            System.out.println("冒泡排序后的数组:");
            // 输出排序后的数组
            for (int num : arr) {
                System.out.print(num + " ");
            }
        }
    }
  2. 插入排序 :

    java 复制代码
    public class InsertionSort {
        // 插入排序方法
        public static void insertionSort(int[] arr) {
            int n = arr.length;
            // 从第二个元素开始遍历数组
            for (int i = 1; i < n; i++) {
                int key = arr[i];
                int j = i - 1;
                // 将当前元素插入到已排序序列的合适位置
                while (j >= 0 && arr[j] > key) {
                    arr[j + 1] = arr[j];
                    j--;
                }
                arr[j + 1] = key;
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {64, 34, 25, 12, 22, 11, 90};
            // 调用插入排序方法对数组进行排序
            insertionSort(arr);
            System.out.println("插入排序后的数组:");
            // 输出排序后的数组
            for (int num : arr) {
                System.out.print(num + " ");
            }
        }
    }
  3. 选择排序 :

    java 复制代码
    public class SelectionSort {
        // 选择排序方法
        public static void selectionSort(int[] arr) {
            int n = arr.length;
            // 外层循环控制当前轮次需要找到的最小元素的位置
            for (int i = 0; i < n - 1; i++) {
                int minIndex = i;
                // 内层循环找到未排序部分的最小元素的索引
                for (int j = i + 1; j < n; j++) {
                    if (arr[j] < arr[minIndex]) {
                        minIndex = j;
                    }
                }
                // 将找到的最小元素与当前位置交换
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {64, 34, 25, 12, 22, 11, 90};
            // 调用选择排序方法对数组进行排序
            selectionSort(arr);
            System.out.println("选择排序后的数组:");
            // 输出排序后的数组
            for (int num : arr) {
                System.out.print(num + " ");
            }
        }
    }

在选择三种排序算法时,一般的算法优先选择顺序是:

  1. 插入排序(Insertion Sort):效率高,特别适合部分有序的数组。
  2. 选择排序(Selection Sort):性能一般,介于冒泡排序和插入排序之间。
  3. 冒泡排序(Bubble Sort):效率较低,不推荐在大规模数据集上使用。
相关推荐
A尘埃6 分钟前
智能工单路由系统(Java)
java·开发语言·智能工单
lingggggaaaa13 分钟前
小迪安全v2023学习笔记(七十八讲)—— 数据库安全&Redis&CouchDB&H2database&未授权&CVE
redis·笔记·学习·算法·安全·网络安全·couchdb
汉克老师14 分钟前
第十四届蓝桥杯青少组C++选拔赛[2023.2.12]第二部分编程题(1、求和)
c++·蓝桥杯·蓝桥杯c++·c++蓝桥杯
Source.Liu17 分钟前
【Python基础】 13 Rust 与 Python 注释对比笔记
开发语言·笔记·python·rust
诗句藏于尽头23 分钟前
DJANGO后端服务启动报错及解决
数据库·笔记·django
失散131 小时前
分布式专题——1.1 Redis单机、主从、哨兵、集群部署
java·数据库·redis·分布式·架构
刘一说1 小时前
Linux调试命令速查:Java/微服务必备
java·linux·微服务
IT·陈寒1 小时前
怎么这么多 StringUtils —— Apache、Spring、Hutool 全面对比
java·spring·apache
汇能感知1 小时前
光谱相机的探测器类型
经验分享·笔记·科技
AAA修煤气灶刘哥2 小时前
MySQL 查文本查哭了?来唠唠 ES 这货:从 “啥是 ES” 到 Java 撸代码,一篇整明白!
java·后端·elasticsearch