几种常见排序算法

最新推荐文章于 2024-07-16 20:27:00 发布

遥远i

最新推荐文章于 2024-07-16 20:27:00 发布

阅读量140

点赞数 1

分类专栏：基本算法问题

本文链接：https://blog.csdn.net/lmix___/article/details/100150110

版权

基本算法问题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

排序方法	时间复杂度	空间复杂度	稳定性
直接插入排序	$O(n^2)$	$O (1)$	稳定
希尔排序	$O(n^{1.3})$	$O (1)$	不稳定
直接选择	$O(n^2)$	$O (1)$	不稳定
堆排序	$O(nlog_{2}n)$	$O (1)$	不稳定
冒泡排序	$O(n^2)$	$O (1)$	稳定
快速排序	$O(nlog_{2}n)$	$O(nlog_{2}n)$	不稳定
归并排序	$O(nlog_{2}n)$	$O (1)$	稳定
基数排序	$O (d (r + n))$	$O(nlog_{2}n)$	稳定

一、稳定排序
1.直接插入排序
$O(n^{2})$

void insSort(int *arr,int n)
{
    for(int i=0;i<n;i++)
    {
        int tmp=arr[i];
        int j=i-1;
        while(j>=0&&tmp<arr[j])
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=tmp;
    }
}

2.冒泡排序
稳定

void bubSort(int *arr,int n)
{
    for(int i=0;i<n;i++)
        for(int j=0;j<n-i-1;j++)
            if(arr[j]>arr[j+1])
                swap(arr[j],arr[j+1]);
}

2.二路归并排序
按照分治思想，将序列分为若干子序列，子序列有序，然后再将子序列合并为整体有序序列。
稳定

3.基数排序
桶子排序，按照基数对整个序列进行多次的排序。
稳定

二、不稳定排序
5.选择排序
不稳定

void selSort(int *arr,int n)
{
    for(int i=0;i<n;i++)
    {
        int MIN_index = i;
        for(int j=i;j<n;j++)
            if(arr[MIN_index]>arr[j]) MIN_index=j;
        swap(arr[MIN_index],arr[i]);
    }
}

6.快速排序
挖坑填坑的过程。
不稳定

void quiSort(int *arr,int l,int r)
{
    if(l>=r) return;
    int base=arr[l];
    int i=l,j=r;
    while(i<j)
    {
        while(arr[j]>=base&&i<j) j--;
        if(i<j) arr[i++]=arr[j];
        while(arr[i]<base&&i<j) i++;
        if(i<j) arr[j--]=arr[i];
    }
    arr[i]=base;
    quiSort(arr,l,i-1);
    quiSort(arr,i+1,r);
}

7.希尔排序
希尔排序就是升级版的插入排序。
不稳定

void sheSort(int *arr,int n)
{
    int gap=n/2;
    while(gap>=1)
    {
        for(int i=gap; i<n; i++)
        {
            int j=i-gap;
            int tmp=arr[i];
            while(j>=0&&tmp<arr[j])
            {
                arr[j+gap]=arr[j];
                j-=gap;
            }
            arr[j+gap]=tmp;
        }
        gap/=2;
    }
}

8.堆排序
不断拿出堆顶结点然后调整大(小)顶堆的过程。
不稳定