排序算法汇总

一、冒泡排序

算法思想：每次将剩余的最大的关键码，逐步上升放在最后一个位置，类似于冒泡。

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void BubbleSort()
{
    for(int i=1;i<=n-1;i++){
        for(int j=1;j<=n-i;j++){
            if(a[j]<a[j+1]) continue;
            else{
                swap(a[j],a[j+1]);
            }
        }
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    BubbleSort();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

改进版冒泡排序：

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void BubbleSort()
{
    for(int i=1;i<=n-1;i++){
        int num=0;
        for(int j=1;j<=n-i;j++){
            if(a[j]<a[j+1]) continue;
            else{
                swap(a[j],a[j+1]);
                num++;
            }
        }
        if(num==0) break;
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    BubbleSort();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

分析复杂度：
时间：O（n²)
空间：O（1）为交换是的辅助变量

二、选择排序

算法思想：每次选择剩余中最小的直接放到放到最前面

#include<bits/stdc++.h>
using namespace std;
#define MAX 10001
int n,a[MAX];
void Select()
{
    int tmp;
    for(int i=1;i<=n;i++){
        tmp=i;
        for(int j=i+1;j<=n;j++){
            if(a[j]<a[tmp]){
                tmp=j;
            }
        }
        swap(a[i],a[tmp]);
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    Select();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

时间复杂度：O(n²)
空间复杂度：O(1)

三、插入排序

算法思想：再前面的序列有序的情况下，不断将新的关键码放入

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void InsertSort()
{
    for(int i=2;i<=n;i++){
        int tmp=i;
        for(int j=i-1;j>=1;j--){
            if(a[tmp]<a[j]){
                swap(a[tmp],a[j]);
                tmp=j;
            }
            else break;
        }
    }
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    InsertSort();
}

时间复杂度：O(n²)
空间复杂度：O(1)

四、希尔排序

基于插入排序，插入排序在数据基本有序的情况下复杂度大大降低，这是将序列分为n/k组，每组进行插入排序，然后逐渐缩小k，直到k=1完成。

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void ShellSort()
{
    for(int d=n/2;d>=1;d/=2){
        for(int i=d;i<=n;i++){
            int tmp=i;
            for(int j=i;j>=1;j-=d){
                if(a[tmp]<a[j]){
                    swap(a[tmp],a[j]);
                    tmp=j;
                }
            }
        }
    }
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    ShellSort();
}

时间复杂度：nlog₂n ~ O(n²)
空间复杂度：O(1)

五、归并排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
//归并排序
//原理：将两个有序的序列合并只需O(n)的时间复杂度
//      递归将序列分为两部分,当元素个数为1时开始合并
//      递归回溯将分开的序列合并，在子序列有序的前提下合并
int n,a[MAX],tmp[MAX];

//合并操作
void Merge(int l,int mid,int r){
    int i=l,j=mid+1,cnt=0;
    while(i<=mid&&j<=r){
        if(a[i]<a[j]){
            tmp[++cnt]=a[i++];
        }
        else tmp[++cnt]=a[j++];
    }
    while(i<=mid) tmp[++cnt]=a[i++];
    while(j<=r) tmp[++cnt]=a[j++];
    for(int i=l;i<=r;i++){
        a[i]=tmp[i-l+1];
    }
}

//递归划分
void MergeSort(int first,int last){
    if(first==last)return;
    int mid=(first+last)/2;
    MergeSort(first,mid);
    MergeSort(mid+1,last);
    Merge(first,mid,last);
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    MergeSort(1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

//复杂度分析
//空间复杂度:需要引用同样存储空间的辅助数组tmp，为O(n)
//时间复杂度:需要log n 趟排序，合并为O(n),这是最好、最坏的时间复杂度

六、快速排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 10001
//快速排序
//以一个数位为基准，小于其的放在左边，大于其的放右边
//然后再递归基准左边、右边

int n,a[MAX];
int geti(int l,int r){
    int i=l,j=r;
    while(i<j){
        while(i<j&&a[i]<a[j]) j--;
        if(i<j){
            swap(a[i],a[j]);
            i++;
        }
        while(i<j&&a[i]<a[j]) i++;
        if(i<j){
            swap(a[i],a[j]);
            j--;
        }
    }
    return i;
}
void QuickSort(int l,int r){
    if(l>=r) return;
    int p=geti(l,r); 
    QuickSort(l,p-1);
    QuickSort(p+1,r);
}
int main()
{
    cin>>n;
    cout<<n<<endl;
    for(int i=1;i<=n;i++) cin>>a[i];
    QuickSort(1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
} 

时间复杂度：O(nlog₂n ~ n²)
空间复杂度：O(1)

七、堆排序

#include<bits/stdc++.h>
using namespace std;
int a[10001],n;
//算法：堆排序
//大根堆：子节点小于父节点
//堆排序分为两部分 建堆、出堆

void shift(int i,int last)//调整堆
{
    int f=i,s=2*i;
    while(s<=last){
        if(s<last&&a[s]<a[s+1]) s++;
        //如果此时s=last,就没有右儿子，左儿子就是最大
        if(a[f]>a[s]) break;//此时已经调整完毕了
        else{
            swap(a[f],a[s]);
            f=s;
            s*=2;
        }
    }
}
void build()
{
    for(int i=n/2;i>=1;i--){
        //从第一个有子节点的结点开始建堆
        //保证无后效性
        if(a[i]<a[2*i]||a[i]<a[2*i+1]){
            shift(i,n);
        }
    }
}
void heapSort()
{
    build();
    for(int i=1;i<n;i++){
        swap(a[1],a[n-i+1]);
        //for(int j=1;j<=n;j++) cout<<a[j]<<" ";cout<<endl;
        shift(1,n-i);
        //for(int j=1;j<=n;j++) cout<<a[j]<<" ";cout<<endl;
        cout<<endl;
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    heapSort();
}

时间复杂度：O（n log₂n）~ n²
空间复杂度：O(1)

八、基数排序

对关键码进行分配与收集的思想进行排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001

struct Node
{
    int data;
    Node* next;
};
int n,maxx,tmp,cnt;

Node* RadixSort(Node *first,int cnt){
    Node *head[10];
    Node *tail[13],*rear;
    int base=1;
    for(int i=1;i<=cnt;i++){
        for(int j=0;j<=9;j++) head[j]=tail[j]=NULL;
        while(first!=NULL){
            int c=((first->data)/base)%10;
            if(head[c]==NULL){
                head[c]=tail[c]=first;
            }
            else{
                tail[c]->next=first;
                tail[c]=first;
            }
            first=first->next;
        }
        for(int j=0;j<=9;j++){
            if(head[j]==NULL)continue;
            else{
                if(first==NULL){
                    rear=first=head[j];
                }
                else{
                    rear->next=head[j];
                }
                rear=tail[j];
            }
        }
        rear->next=NULL;
        base*=10;
    }
    Node *p=first;
    return first;
}
int main()
{
    cin>>n;
    Node *first,*rear,*p;
    first=rear=NULL;
    for(int i=1;i<=n;i++){
        cin>>tmp;
        p=new Node();
        p->data=tmp;
        if(first==NULL) first=rear=p;
        else{
            rear=rear->next=p;
        }
        maxx=max(tmp,maxx);
    }
    rear=rear->next=NULL;
    while(maxx){
        maxx/=10;
        cnt++;
    }
    first=RadixSort(first,cnt);
    p=first;
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

时间复杂度：近乎线性O（n+m）
空间复杂度：O（m）