数据结构算法-冒泡排序算法

引言

虽然选择排序好用，但有点问题也就是频繁找最大值下标放到未排序的后面
因为每次需要扫描整个未排序序列，找到最大值或最小值的下标，并将其交换到未排序序列的最后一个位置。这样做的问题在于，在后面的迭代中，我们仍然需要扫描整个未排序序列，包括已经排序好的部分，这是浪费时间的。

另外，选择排序是不稳定的排序算法，因为在找到最大值或最小值的下标时，并没有考虑值相同的元素的顺序。如果有多个相同值的元素，交换它们的位置可能会打乱它们的相对顺序

也就是说相同的元素也交换可能位置有变化
对于相同的元素，它们在排序后的位置可能会改变，因为冒泡排序会将相邻的两个元素进行比较和交换，这样相同的元素就可能会在排序过程中交换位置。对于选择排序而言，它在找到最大值或最小值的下标时，并没有考虑值相同的元素的顺序，因此如果有多个相同值的元素，交换它们的位置可能会打乱它们的相对顺序。因此选择排序也是不稳定的排序算法。

冒泡排序算法思想

在这里插入图片描述

在这里插入图片描述
到i=2的时候已经是排序了那么这里应该如何优化？
如果有一种机制一开始默认已排序在内层循环判断第一个比第二大发生交换的时候制定为false
内层循环结束判断这个排序标志为真排序完成直接退出外层循环

冒泡排序的基本思想是，通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底的气泡一样逐渐向上冒。
在这个过程中，每次内循环都会将当前未排序部分的最大元素“冒泡”到其最终位置。因此，每次外循环之后，未排序部分的元素数目会减少一个。

冒泡排序算法专区

// 定义一个名为bubbleSort的函数，它接收两个参数：一个名为arr的整数数组和一个名为size的整数，表示数组的大小  
void bubbleSort(int arr[], int size) {  
  
    // 外层循环，用于控制排序的轮数。因为每一轮都会将最大的元素移动到数组的末尾，所以最多需要size-1轮。  
    for (int i = 0; i < size - 1; i++) {    
          
        // 内层循环，用于在每一轮中逐一比较相邻的元素。由于每一轮都会确保最大的元素移动到其应在的位置，因此内层循环只需要遍历到“size-1-i”即可。  
        for (int j = 0; j < size - 1 - i; j++) {    
              
            // 如果当前元素大于下一个元素，则交换它们的位置。这是冒泡排序的核心操作。  
            if (arr[j] > arr[j+1]) {    
                  
                // 调用swap函数交换两个元素的值。
                swap(arr[j], arr[j+1]);    
            }    
        }    
    }    
}
}

优化：

// 定义一个名为bubbleSort的函数，接收一个整数数组arr和数组的大小size作为参数  
void bubbleSort(int arr[], int size) {  
  
    // 外层循环，遍历整个数组  
    for (int i = 0; i < size - 1; i++) {    
          
        // 定义一个布尔变量swapped，用于记录是否发生了交换  
        bool swapped = false; // 用于记录是否发生了交换    
          
        // 内层循环，比较相邻的元素并进行交换  
        for (int j = 0; j < size - 1 - i; j++) {    
              
            // 如果当前元素大于下一个元素，则进行交换  
            if (arr[j] > arr[j+1]) {    
                  
                // 调用swap函数交换两个元素的值  
                swap(arr[j], arr[j+1]);    
                  
                // 将swapped设为true，表示发生了交换    
                swapped = true; // 发生了交换，将swapped设为true    
            }    
        }    
          
        // 如果内层循环结束时，swapped仍然为false，说明数组已经是有序的，直接退出外层循环  
        if (!swapped) break; // 如果内层循环结束时，swapped仍然为false，说明数组已经是有序的，直接退出外层循环    
    }    
}

升/降序通用

// 定义一个函数 BubbleSort，接受一个整数数组 arr，数组的大小 size，和一个比较函数 cmp 作为参数。这个函数用来对数组进行冒泡排序。  
void  BubbleSort(int arr[], int size, bool(*cmp)(const int&, const int&)) {  
  
    // 检查传入的比较函数是否为空。如果为空，则直接返回，不进行任何操作。  
    if (cmp == nullptr) {  
        return;  
    }  
  
    // 开始进行外层循环，从数组的第一个元素到倒数第二个元素（i 从 0 到 size-2）  
    for (int  i = 0; i < size-1; i++){  
  
        // 定义一个布尔变量 IsSort，初始值为 true。这个变量用来检查数组是否已经有序。  
        bool IsSort = true;  
  
        // 进行内层循环，从数组的第二个元素开始到倒数第三个元素（j 从 0 到 size-1-i）  
        for (int j= 0; j < size-1-i; j++){  
  
            // 使用比较函数 cmp 来判断 arr[j] 是否大于 arr[j + 1]。如果大于，则交换这两个元素的位置，并将 IsSort 设为 false。  
            if (cmp(arr[j], arr[j + 1])) {  
                swap(arr[j], arr[j + 1]);  
                IsSort = false;  
            }  
        }  
  
        // 如果 IsSort 仍然为 true，说明这个位置的元素已经是有序的，可以结束内层循环。  
        if (IsSort)	{  
            break;  
        }  
    }  
}  
  
// 定义一个函数 GreaterCmp，接受两个整数作为参数，如果第一个整数大于第二个整数，返回 true，否则返回 false。这个函数用于比较两个整数的大小。  
bool GreaterCmp(const int& val1, const int &val2) {  
    return val1 > val2;  
}  
  
// 定义一个函数 LessCmp，接受两个整数作为参数，如果第一个整数小于第二个整数，返回 true，否则返回 false。这个函数用于比较两个整数的大小。  
bool LessCmp(const int& val1, const int& val2) {  
    return val1 < val2;  
}