排序算法总结

最新推荐文章于 2024-10-22 17:17:53 发布

goldfish3

最新推荐文章于 2024-10-22 17:17:53 发布

阅读量292

点赞数

CC 4.0 BY-SA版权

分类专栏：算法和刷题

本文链接：https://blog.youkuaiyun.com/goldfish3/article/details/89388113

算法和刷题专栏收录该内容

14 篇文章

订阅专栏

本文深入讲解了O(n^2)的排序算法，包括选择排序、插入排序和冒泡排序的实现与优化，以及O(nlogn)的归并排序和快速排序的原理与应用。通过对比不同算法的性能，阐述了在特定场景下简单排序算法的优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

O(n^2)

为什么要学习O(n^2)的排序算法？

编码简单，易于实现
在某些特殊情况，简单的算法更有效
简单算法的思想衍生出复杂的排序算法（如插入排序 -> 希尔排序）
作为子过程，改进更复杂的排序算法

选择排序

template<typename T>
void selectSort(T arr[], int len){
    for (int i = 0; i < len; ++i) {
        int minIndex = i;
        for (int j = i; j < len; ++j) {
            if (arr[j] < arr[minIndex]){
                minIndex = j;
            }
        }
        swap(arr[i],arr[minIndex]);
    }
}

插入排序： 从后面选一个元素，插入前面已经有序的元素中
原始版：

template <typename T>
void insertSort(T arr[], int len){
    for (int i = 0; i <len ; ++i) {
        for (int j = i; j > 0 && arr[j-1]>arr[j] ; --j) {
            swap(arr[j],arr[j-1]);
        }
    }
}

改进版，不需要多次交换

template <typename T>
void insertSort(T arr[], int len){
    for (int i = 0; i <len ; ++i) {
        T tmp = arr[i];
        int j;
        for (j = i ; j > 0 && arr[j-1] > tmp ; --j) {
            arr[j] = arr[j-1];
        }
        arr[j] = tmp;
    }
}

改进后的插入排序速度快于选择排序
在这里插入图片描述
插入排序对于近乎有序的序列，性能非常高（o(n)）,所以在实际生产环境中，用的也挺多，也会作为子过程加入后面介绍的算法中。

冒泡排序：
速度很慢的一个排序算法

template <typename T>
void bubbleSort(T arr[], int len){
    for (int i = 0; i < len; ++i) {
        for (int j = 1; j < len-i; ++j) {
            if (arr[j-1] > arr[j]){
                swap(arr[j-1],arr[j]);
            }
        }
    }
}

O(nlogn)

归并排序

非原地排序，需要O(n)的空间复杂度
在这里插入图片描述
红色索引元素比较，小的放上去

使用自顶向下的方式排序

template <typename T>
void merge(T arr[],int l,int m,int r){
    T aux[r-l+1];
    for (int i = l; i <= r ; ++i) {
        aux[i-l] = arr[i];
    }
    int i = l,j = m+1;
    for (int k = l; k <= r; ++k) {
        if (i > m){
            arr[k] = aux[j++ - l];
        }else if(j > r){
            arr[k] = aux[i++ - l];
        }else if (aux[i-l] <= aux[j-l]){
            arr[k] = aux[i++ - l];
        }else{
            arr[k] = aux[j++ - l];
        }
    }
}

//对[l,r]之间的元素进行排序
template <typename T>
void mergeSortCore(T arr[],int l,int r){
    if (l >= r){
        return;
    }
    int m = (l + r) / 2;
    mergeSortCore(arr,l,m);
    mergeSortCore(arr,m+1,r);
    if (arr[m] > arr[m+1])   //优化
        merge(arr,l,m,r);
}

template <typename T>
void mergeSort(T arr[], int len){
    mergeSortCore(arr,0,len-1);
}

快速排序

单路快拍（多路不写）

using namespace std;

int partition(vector<int>& vec, int low, int high){
    int pivokey = vec[low];
    while (low < high){
        while (low < high && vec[high] >= pivokey)
            high--;
        swap(vec[low],vec[high]);
        while (low < high && vec[low] < pivokey)
            low++;
        swap(vec[low],vec[high]);
    }
}

void quickSort(vector<int>& vec,int start,int end){
    if (start >= end){
        return;
    }
    int pivot = partition(vec,start,end);
    quickSort(vec,start,pivot-1);
    quickSort(vec,pivot+1,end);
}


int main(){
    vector<int> vec = {1,3,45,1,2,3,65,1,3,6};
    quickSort(vec,0,vec.size()-1);
    for (int i = 0; i < vec.size(); ++i) {
        cout << vec[i] << " ";
    }
    cout << endl;
}