冒泡排序和选择排序详细讲解(附加代码注释)

冒泡排序

冒泡排序是一种简单直观的排序算法，其名字来源于排序过程中较大的元素会像气泡一样逐渐"浮"到数列的顶端。

算法原理

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现

以下是Java实现的冒泡排序算法：

public static void main(String[] args) {
    // 需求：有如下一组数{67, 42, 88, 16, 25, 3}，对其按从小到大的顺序排列。
    // 分析：
    // 1.创建一个数组保存上述数据
    // 2.使用冒泡法进行排序
    // 原始数据 67 42 88 16 25 3------一共6个数据，共比较5趟
    // 第1趟，一共比较5次
    //  第1次 42 67 88 16 25 3
    //  第2次 42 67 88 16 25 3
    //  第3次 42 67 16 88 25 3
    //  第4次 42 67 16 25 88 3
    //  第5次 42 67 16 25 3 88-----88不再参与下一轮比较。第1趟找出了最大值
    // 第2趟，一共比较4次
    //  第1次 42 67 16 25 3 88
    //  第2次 42 16 67 25 3 88
    //  第3次 42 16 25 67 3 88
    //  第4次 42 16 25 3 67 88-----67和88不再参与下一轮比较，第2趟找出了第2大值。
    // 第3趟，一共比较3次
    //  第1次 16 42 25 3 67 88
    //  第2次 16 25 42 3 67 88
    //  第3次 16 25 3 42 67 88-----42,67,88不再参与下一轮比较，第3趟找出了第3大值
    // 第4趟，一共比较2次
    //  第1次 16 25 3 42 67 88
    //  第2次 16 3 25 42 67 88-----25,42,67,88不再参与下一轮比较，第4趟找出了第4大值
    // 第5趟，一共比较1次
    //  第1次 3 16 25 42 67 88-----全部数据有序。

  // 初始化待排序的数组
int[] array = {67, 42, 88, 16, 25, 3};

// 外层循环，控制排序趟数
for(int i = 0; i < array.length - 1; i++) {
    // 内层循环，比较相邻的两个元素
    for(int j = 0; j < array.length - 1 - i; j++) {
        // 如果前一个元素大于后一个元素，则交换它们的位置
        if(array[j] > array[j + 1]) {
            // 使用临时变量进行元素交换
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
    // 每完成一趟排序，最大的元素就会被移到数组末尾
}

// 打印排序后的数组
for(int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
}
// 换行
System.out.println();

}

冒泡排序的固定格式

冒泡排序的核心代码格式通常如下：

for (int i = 0; i < 数组名.length - 1; i++) {
    for (int j = 0; j < 数组名.length - 1 - i; j++) {
        if (数组名[j] > 数组名[j+1]) {
            数据类型 temp = 数组名[j];
            数组名[j] = 数组名[j+1];
            数组名[j+1] = temp;
        }
    }
}

算法分析

• 时间复杂度：O(n^2)，其中n是数组的长度。
• 空间复杂度：O(1)，只需要常数级的额外空间。
• 稳定性：冒泡排序是稳定的排序算法。
  尽管冒泡排序简单易懂，但由于其平方级的时间复杂度，在处理大规模数据时效率较低。然而，对于小规模数据或接近有序的数据，冒泡排序仍然是一个不错的选择。

选择排序

算法思想

选择排序思想：以从小到大排序为例。

1. 第一趟：从数组中找出最小值，并记录最小值的下标，让最小值与数组下标为0的元素交换位置。
2. 第二趟：刨除数组下标为0的元素，在剩下的元素中找出最小值，并记录最小值的下标，与数组下标为1的元素交换位置。
3. 第三趟：刨除数组下标为0和1的元素，在剩下的元素中找出最小值，并记录最小值的下标，与数组下标为2的元素交换位置。
4. 以此类推，如果要对n个数排序，n-1趟即可让数组有序。

需求

有如下一组数{67, 42, 88, 16, 25, 3}，对其按从小到大的顺序排列。

代码实现

public static void main(String[] args) {
    // 需求：有如下一组数{67, 42, 88, 16, 25, 3}，对其按从小到大的顺序排列。
    // 分析：
    // 1.创建一个数组保存上述数据
    // 2.定义变量index保存最小值的下标。
    // 3.使用选择排序法进行排序
    // 原始数据 67 42 88 16 25 3------一共6个数据，共比较5趟
  // 初始化待排序的数组
int[] array = {67, 42, 88, 16, 25, 3};

// 外层循环，控制排序趟数
for(int i = 0; i < array.length - 1; i++) {
    // 假设当前索引i处的元素为最小值
    int index = i;
    
    // 内层循环，从i+1开始遍历剩余的元素
    for(int j = i + 1; j < array.length; j++) {
        // 如果找到比当前最小值更小的元素
        if(array[j] < array[index]) {
            // 更新最小值的索引
            index = j;
        }
    }
    
    // 如果最小值的索引不是i，说明找到了更小的元素
    if(index != i){
        // 交换当前位置i和最小值位置index的元素
        int temp = array[index];
        array[index] = array[i];
        array[i] = temp;
    }
}

// 打印排序后的数组
for(int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
}
// 换行
System.out.println();

}

选择排序的固定写法

选择排序的写法很固定：

for(int i = 0; i < 数组名.length - 1; i++){
    int index = i;
    for(int j = i + 1; j < 数组名.length; j++){
        if(数组名[j] < 数组名[index]){
            index = j;
        }
    }
    if(index != i){
        数据类型 temp = 数组名[i];
        数组名[i] = 数组名[index];
        数组名[index] = temp;
    }
}