排序算法相关

冒泡排序

冒泡排序（Bubble Sort）是一种基础的排序算法，其核心思想是多次遍历待排序的序列，并在每次遍历中逐步将最大（或最小）的元素“冒泡”至序列的末端。时间复杂度 o(n2),空间复杂度：o(1),以下是一个用C++编写的冒泡排序实现示例：

#include <iostream>
#include <vector>

// 冒泡排序函数，接收一个整数向量作为参数，并对其进行原地排序
void bubbleSort(std::vector<int>& arr) {
    int n = arr.size();
    // 外层循环控制遍历次数
    for (int i = 0; i < n - 1; ++i) {
        // 内层循环进行元素间的比较和交换
        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                // 交换arr[j]和arr[j + 1]
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// 打印向量内容的辅助函数
void printVector(const std::vector<int>& arr) {
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main() {
    // 初始化一个待排序的整数向量
    std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
    
    // 输出排序前的向量内容
    std::cout << "排序前的数组: ";
    printVector(arr);
    
    // 调用冒泡排序函数对向量进行排序
    bubbleSort(arr);
    
    // 输出排序后的向量内容
    std::cout << "排序后的数组: ";
    printVector(arr);
    
    return 0;
}

快速排序

快速排序（Quicksort），又称划分交换排序（partition-exchange sort），是一种非常高效且广泛应用的排序算法。它采用了分治策略，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。时间复杂度：O(nlogn)

#include <iostream>
#include <vector>

// 快速排序的分区函数
int partition(std::vector<int>& nums, int low, int high) {
    int pivot = nums[high];  // 选择最后一个元素作为基准
    int i = low - 1;  // i是小于基准的区间的最后一个元素的索引

    for (int j = low; j < high; ++j) {
        if (nums[j] < pivot) {
            ++i;  // 将i移动到下一个位置
            std::swap(nums[i], nums[j]);  // 交换nums[i]和nums[j]
        }
    }
    std::swap(nums[i + 1], nums[high]);  // 将基准元素放到正确的位置
    return i + 1;
}

// 快速排序函数
void quickSort(std::vector<int>& nums, int low, int high) {
    if (low < high) {
        int pi = partition(nums, low, high);  // 获取分区索引

        // 递归地对左右子数组进行快速排序
        quickSort(nums, low, pi - 1);
        quickSort(nums, pi + 1, high);
    }
}

int main() {
    std::vector<int> nums = {3, 6, 8, 10, 1, 2, 1};
    
    quickSort(nums, 0, nums.size() - 1);
    
    // 输出排序后的数组
    for (int num : nums) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

选择排序

选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是：首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。这个过程会一直重复，直到所有元素均排序完毕。时间复杂度 o(n2)

#include <iostream>
#include <vector>

// 选择排序函数
void selectionSort(std::vector<int>& arr) {
    int n = arr.size();
    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;
            }
        }
        // 将找到的最小值与当前元素交换
        std::swap(arr[i], arr[minIndex]);
    }
}

int main() {
    // 定义一个待排序的数组
    std::vector<int> arr = {64, 25, 12, 22, 11};

    // 调用选择排序函数
    selectionSort(arr);

    // 输出排序后的数组
    std::cout << "Sorted array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}