数据结构-交换类排序-CSDN博客

本文链接：https://blog.csdn.net/weixin_63610043/article/details/140637893

1.1 冒泡排序

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它通过多次遍历待排序的元素，比较相邻元素的大小，并交换它们，直到整个序列有序。

算法步骤

1. 初始状态：从第一个元素开始，依次比较相邻的两个元素。
2. 比较和交换：如果前一个元素比后一个元素大，则交换它们。
3. 重复遍历：对每一对相邻元素重复上述步骤，直到没有元素需要交换为止。

void BubbleSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i) {    //外层循环控制遍历的次数，总共需要进行 n-1 次遍历。
        for (int j = 0; j < n - 1 - i; ++j) {    //内层循环控制每次遍历中相邻元素的比较和交换，随着外层循环的进行，内层循环的范围逐渐减小。
            if (a[j] > a[j + 1]) {
                swap(a[j], a[j + 1]);    //比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们。
            }
        }
    }
}

时间复杂度

·最优时间复杂度：O(n)（当数组已经有序时）

·最坏时间复杂度：O(n²)（当数组逆序时）

平均时间复杂度：O(n²)

空间复杂度

·空间复杂度：O(1)（只需要常数级别的额外空间）

引入标志位

在冒泡排序中引入一个标志位可以有效地减少不必要的比较操作。当在某一趟排序中没有发生任何交换时，说明数组已经有序，可以提前结束排序过程。

void BubbleSort(int a[], int n) {
    bool swapped; // 定义标志位
    for (int i = 0; i < n - 1; ++i) {
        swapped = false; // 每次外层循环开始时重置标志位
        for (int j = 0; j < n - 1 - i; ++j) {
            if (a[j] > a[j + 1]) {
                swap(a[j], a[j + 1]);
                swapped = true; // 发生交换，设置标志位为 true
            }
        }
        if (!swapped) { // 如果没有发生交换，提前结束排序
            break;
        }
    }
}

1.2 快速排序

快速排序（Quick Sort）是一种高效的排序算法，采用了分治法（Divide and Conquer）的思想。它通过选择一个基准元素，将数组分成两部分，递归地对这两部分进行排序，最终使整个数组有序。

算法步骤

1. 选择基准元素：从数组中选择一个元素作为基准（pivot）。

2.分区过程：将数组分成两部分，比基准元素小的元素放在左边，比基准元素大的元素放在右边。

3. 递归排序：对左边和右边的子数组分别递归进行快速排序。

void QuickSort(int a[], int left, int right) {
    if (left < right) {
        int i = left, j = right;
        int pivot = a[left]; // 选择左边第一个元素作为基准
        while (i < j) {
            while (i < j && a[j] >= pivot) j--; // 从右向左找小于基准的元素
            if (i < j) a[i++] = a[j]; // 将小于基准的元素移到左边
            while (i < j && a[i] <= pivot) i++; // 从左向右找大于基准的元素
            if (i < j) a[j--] = a[i]; // 将大于基准的元素移到右边
        }
        a[i] = pivot; // 将基准元素放到正确位置
        QuickSort(a, left, i - 1); // 递归排序左子数组
        QuickSort(a, i + 1, right); // 递归排序右子数组
    }
}