数据结构与算法--排序-CSDN博客

本文链接：https://blog.csdn.net/philosopher123/article/details/139095251

常见面试题，以下使用C++解答5种常见排序方式。

以下排序皆为从小到大。

头文件及测试程序：

#include <iostream>
#include <vector>
using namespace std;

// -------------------
// 排序函数sort()放在这
// -------------------

// 测试数据
int main()
{
    vector<int> nums = {1, 3, 10, 18, 13, 2, 7, 9, 17};
    // 调用相应sort()
    mergeSort(nums, 0, nums.size() - 1);
    for (auto num: nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

1. 选择排序

解释：每次选择最小的，扔到最前面，剩余元素重复操作，即完成排序。

程序示例：

void selectSort(vector<int> &nums) {
    int n = nums.size();
    for (int i = 0; i < n; ++i) {
        int minIndex = i;
        for (int j = i + 1; j < n; ++j) {
            if (nums[j] < nums[minIndex]) {
                // 内层循环，找到最小值对应索引
                minIndex = j;
            }
        }
        // 最小值扔到当前范围队头
        swap(nums[i], nums[minIndex]);
    }
}

时间复杂度：显然O（n^2）;

2. 冒泡排序

解释：相邻元素比较，并交换。

程序：

void bubbleSort(vector<int> &nums) {
    int n = nums.size();
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if (nums[i] > nums[j]) {
                // 符合条件时，不断与当前i交换
                swap(nums[i], nums[j]);
            }
        }
    }
}

程序上与选择排序很像。

区别在于，选择排序寻找索引，只交换一次；冒泡交换多次。

时间复杂度：O（n^2）；

3. 插入排序

类似于扑克牌的排序，每抽一张扑克牌，将扑克牌插入正确的位置使之有序。

解释：每抽一张牌，与前面的数比较，插入正确位置。

程序：

void insertSort(vector<int> &nums) {
    int n = nums.size();
    // 开始抽牌
    for (int i = 0; i < n; ++i) {
        // 定义当前牌，前一张牌索引
        int cur = nums[i], j = i - 1;
        while (j >= 0 && cur < nums[j]) {
            // 当前牌更小，前一张牌后移
            nums[j + 1] = nums[j];
            // 比较前前一张牌
            --j;
        }
        // 循环终止时，在比较的牌j 后面一个位置放置cur当前牌
        nums[j + 1] = cur;
    }
}

时间复杂度：O(n ^ 2);

4. 快速排序

解释：

使用“哨兵”划分。选一个基准数base， < base 的数扔左边， > base的数扔右边；
形成：左边 < base < 右边。
重复操作：在左边选择leftBase，重复以上操作，右边同理；

显然，属于分治算法，大问题分解为左右两边子问题。

程序：

// 快排一次，返回基准数base划分后的索引
int partition(vector<int>& arr, int low, int high) {
    // 选择base
    int pivot = arr[high]; 
    int i = (low - 1);     

    for (int j = low; j <= high - 1; j++) {
        // 如果当前数小于base
        if (arr[j] < pivot) {
            i++; 
            // 将小于base的数arr[j]扔到前面去
            swap(arr[i], arr[j]);
        }
    }
    // 将base 放到分界线i + 1处
    swap(arr[i + 1], arr[high]);
    // 返回分界线i + 1
    return (i + 1);
}

// 递归函数用于快速排序
void quickSort(vector<int>& arr, int low, int high) {
    if (low >= high) return;
    // 开始划分，返回分界线index
    int pi = partition(arr, low, high);

    // 递归排序子问题
    quickSort(arr, low, pi - 1);
    quickSort(arr, pi + 1, high);
}

平均时间复杂度：递归层数O(logn), 划分1次O(n)，总体O（nlogn）；

5. 归并排序

解释：基于分治思想，将大问题分为子问题。具体来讲将nums中的数字从中间mid一分为二、二分为四......，直至每段长度为1，然后开始合并。

程序上：分治算法多数基于递归实现，因为子问题可以调用函数本身处理；

void merge(vector<int> &nums, int left, int mid, int right) {
    vector<int> temp(right - left + 1);
    int i = left, j = mid + 1;
    int k = 0;
    while(i <= mid && j <= right) {
        if (nums[i] < nums[j]) {
            temp[k++] = nums[i++];
        } else{
            temp[k++] = nums[j++];
        }
    }
    // 剩余元素加入temp
    while (i <= mid) {
        temp[k++] = nums[i++];
    }
    while(j <= right) {
        temp[k++] = nums[j++];
    }
    // 将temp的值赋值给原nums
    for (int k = 0; k < temp.size(); ++k) {
        nums[left + k] = temp[k];
    }
}

void mergeSort(vector<int> &nums, int left, int right) {
    // 终止条件
    if (left >= right) return;
    int mid = left + (right - left) / 2;

    // 子问题排序
    mergeSort(nums, left, mid);
    mergeSort(nums, mid+ 1, right);

    // 合并子问题
    merge(nums, left, mid, right);
}

分治使用递归的方法，在程序中一定先判定终止条件，不然子问题无法退出。

时间复杂度O（nlogn）。