【算法系列】常见排序算法：冒泡排序、选择排序与插入排序

最新推荐文章于 2025-05-09 22:37:14 发布

binbinxyz

最新推荐文章于 2025-05-09 22:37:14 发布

阅读量918

点赞数 8

CC 4.0 BY-SA版权

文章标签：算法排序算法数据结构

本文链接：https://blog.youkuaiyun.com/binbinxyz/article/details/145855705

常见排序算法详解：冒泡排序、选择排序与插入排序

排序算法是计算机科学中的基础问题之一，广泛应用于各种场景。本文将详细介绍三种常见的简单排序算法：冒泡排序、选择排序和插入排序。这些算法虽然在处理大规模数据时效率不如更复杂的算法（如快速排序、归并排序），但它们易于理解和实现，非常适合初学者学习和理解排序的基本原理。

1. 冒泡排序（Bubble Sort）

在这里插入图片描述

1.1 基本原理

冒泡排序通过重复地遍历要排序的列表，依次比较相邻的元素并交换它们的位置，使得每一轮遍历后最大的元素逐渐“冒泡”到列表的一端。

步骤：

从数组的第一个元素开始，依次比较相邻的两个元素。
如果前一个元素大于后一个元素，则交换这两个元素的位置。
重复上述过程，直到没有需要交换的元素为止。

1.2 时间复杂度

最好情况：O(n) （已经有序的情况）
平均和最坏情况：O(n^2)

1.3 空间复杂度

O(1) （原地排序）

1.4 稳定性

稳定（相同值的相对位置不会改变）

1.5 Java 实现示例

public static void bubbleSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int length = arr.length - i;
        boolean swap = false;
        for (int j = 0; j < length; j++) {
            // 交换元素以便将较大的元素冒泡
            if(arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swap = true;
            }
        }
        if(!swap) {
            break;
        }
    }
}

2. 选择排序（Selection Sort）

2.1 基本原理

选择排序每次从未排序部分中选出最小（或最大）的元素，并将其放到已排序部分的末尾。

步骤：

从未排序部分中找到最小的元素。
将该元素与未排序部分的第一个元素交换位置。
重复上述过程，直到整个数组排序完成。

2.2 时间复杂度

O(n^2)

2.3 空间复杂度

O(1) （原地排序）

2.4 稳定性

不稳定（相同值的相对位置可能会改变）

2.5 Java 实现示例

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        // 假定当前元素最小
        int minIndex = i;
        // 循环遍历未排序部分，查找最小元素的索引
        for (int j = i + 1; j < arr.length; j++) {
            if(arr[minIndex] > arr[j]) {
                minIndex = j;
            }
        }

        // 把最小元素挪到当前正确位置
        if(minIndex > i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3. 插入排序（Insertion Sort）

3.1 基本原理

插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

步骤：

从第二个元素开始遍历数组。
将当前元素与前一个元素进行比较，如果当前元素小于前一个元素，则交换它们的位置，并继续向前比较，直到找到正确的位置。
对每个元素重复上述步骤，直到整个数组排序完成。

3.2 时间复杂度

最好情况：O(n) （已经有序的情况）
平均和最坏情况：O(n^2)

3.3 空间复杂度

O(1) （原地排序）

3.4 稳定性

稳定（相同值的相对位置不会改变）

3.5 Java 实现示例

public static void insertSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int j = i;
        int key = arr[i];

        // 比当前元素大的数往右移动
        while(j > 0 && key < arr[j - 1]) {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}