十大排序算法(C++版)

Rong_Jie

于 2019-07-04 12:12:35 发布

阅读量151

点赞数

分类专栏：算法与数据结构文章标签：十大排序算法 C++

本文链接：https://blog.csdn.net/qq_23301117/article/details/94603955

版权

算法与数据结构专栏收录该内容

10 篇文章 0 订阅

订阅专栏

十大排序算法

排序算法

排序算法

排序算法总结

冒泡排序

#include <bits/stdc++.h>
using namespace std;
//时间复杂度 最好的：O(n^2), 最坏：O(n^2),平均：O(n^2),空间复杂度：O(1),稳定
//改善的冒泡排序 最好：O(n) 最好 O(n^2) 平均 O(n^2)
void bubble(int a[],int length){

    for(int i=1;i<length;i++){
        bool flag=false;
        for(int j=0;j<length-i;j++){
            if(a[j]>a[j+1]){
                swap(a[j],a[j+1]);
                flag=true;
            }
        }
        if(flag==false) break;
    }
}

快速排序

//快速排序：最好时间复杂度：O(nlogn),最差时间复杂度：O(nlogn),平均时间复杂度：O(nlogn),空间复杂度：O(logn),不稳定

int par(int a[],int length,int i,int j){
    if(a==nullptr || length<=0 || i<0 || j>=length) {
        cout<<"parameter is invalid"<<endl;
        exit(0);
    }

    int index=i+rand()%(j-i+1);
    swap(a[index],a[i]);
    int temp=a[i];
    while(i<j){
        while(i<j && a[j]>=temp) --j;
        if(i<j) a[i]=a[j];
        while(i<j && a[i]<temp) ++i;
        if(i<j) a[j]=a[i];
    }
    a[i]=temp;
    return i;
}

void quickSort(int a[],int length,int i,int j){
    if(i==j) return;
    int index=par(a,length,i,j);
    if(index>i){
        quickSort(a,length,i,index-1);
    }
    if(index<j){
        quickSort(a,length,index+1,j);
    }
}

插入排序

//插入排序，最坏的时间复杂度：O(n^2),最好的时间复杂度为：O(n),平均时间复杂度为：O(n^2),空间复杂度：O(1),稳定
void insertSort(int a[],int length){
    for(int i=1;i<length;i++)
        for(int j=i-1;j>=0 && a[j]>a[j+1]; j--)
            swap(a[j],a[j+1]);
}

希尔排序

//希尔排序,最坏时间复杂度：O(n^2),最好的时间复杂度：O(n),平均时间复杂度：O(n^1.3);空间复杂度：O(1),不稳定

void shellSort(int a[],int length){
    int gap=length/2;
    while(gap>0){
        //gap=gap/3+1;
        for(int i=gap;i<length;i++){
            int cur=a[i];
            int preIndex=i-gap;
            while(preIndex>=0 && a[preIndex]>cur){
                a[preIndex+gap]=a[preIndex];
                preIndex-=gap;
            }
            a[preIndex+gap]=cur;
        }
        gap=gap/2;
    }
}


void shellSort2(int a[], int length){
    if(a==nullptr || length<=0){
        cout<<"invalid parameters"<<endl;
        exit(0);
    }

    int gap=length/2;
    while(gap>0){
        for(int i=gap;i<length;i++){
            int cur=a[i];
            int preIndex=i-gap;
            while(preIndex>=0 && a[preIndex]>cur){
                a[preIndex+gap]=a[preIndex];
                preIndex=preIndex-gap;
            }
            a[preIndex+gap]=cur;
        }
        gap=gap/2;
    }
}

选择排序

//选择排序：最好的时间复杂度：O(n^2),最差的时间复杂度：O(n^2),平均时间复杂度：O(n^2),空间复杂度：O(1),不稳定
void selectSort(int a[],int length) {
    for(int i=0;i<length-1;i++){
        int minIndex=i;
        for(int j=i+1;j<length;j++){
            if(a[j]<a[minIndex])
                minIndex=j;
        }
        swap(a[i],a[minIndex]);
    }
}

堆排序

//堆排序，最好时间复杂度：O(nlogn),最差时间复杂度：O(nlogn),平均时间复杂度：O(nlogn),空间复杂度：O(1),不稳定


void bulidHeap(int a[], int length,int index) {
    int temp=a[index];
    for(int k=index*2+1;k<length;k=k*2+1){
        if(k+1<length && a[k]<a[k+1]) ++k;
        if(a[k]>temp){
            a[index]=a[k];
            index=k;
        }else break;
    }

    a[index]=temp;
}

void heapSort(int a[],int len){
    for(int i=len/2-1;i>=0;i--)//从第一个非叶子结点开始
        bulidHeap(a,len,i);
    for(int j=len-1;j>0;j--){
        swap(a[0],a[j]);
        bulidHeap(a,j,0);
    }

}

归并排序

//归并排序,最好的时间复杂度：O(nlogn),最好的时间复杂度：O(nlogn),平均时间复杂度：O(nlogn),空间复杂度：O(n),稳定
void merge(int a[],int L,int M,int R){
    int *cent=new int[R-L+1];
    int i=0;
    int pFirst=L;
    int pSecond=M+1;
    while(pFirst<=M && pSecond<=R){
        cent[i++]=a[pFirst]<a[pSecond]?a[pFirst++]:a[pSecond++];
    }
    while(pFirst<=M) cent[i++]=a[pFirst++];
    while(pSecond<=R) cent[i++]=a[pSecond++];
    for(int j=0;j<(R-L+1);j++)
        a[L+j]=cent[j];
    delete[] cent;
}


void mergeSort(int a[],int L,int R){
    if(L==R) return;
    int mid=(L+R)/2;
    mergeSort(a,L,mid);
    mergeSort(a,mid+1,R);
    merge(a,L,mid,R);
}

void mergeSort(int a[],int length){
    if(a==nullptr || length<1) return;
    mergeSort(a,0,length-1);
}

桶排序

对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：
O(N)+O(M*(N/M)log(N/M))=O(N+N(logN-logM))=O(N+NlogN-NlogM)

//桶排序：最差时间复杂度：O(n^2),最好时间复杂度：O(n),平均时间复杂度：O(n+k),空间复杂度：O(n+k),稳定
void insertNum(list<int> &bucket,int val){
    auto iter=bucket.begin();
    while(iter!=bucket.end() && val>=*iter) ++iter;
    bucket.insert(iter,val);
}

void bucketSort(int a[],int length){
    if(a==nullptr || length<=1) return;
    int mina=a[0],maxa=a[0];
    for(int i=0;i<length;i++){
        mina=min(a[i],mina);
        maxa=max(a[i],maxa);
    }

    int k=10;
    int bucketNumber=(maxa-mina)/k+1;

    vector<list<int>> buckets(bucketNumber);
    for(int i=0;i<length;i++){
        int val=a[i];
        insertNum(buckets[(val-mina)/k],val);
    }

    int index=0;
    for(int i=0;i<bucketNumber;i++){
        if(buckets[i].size()>=0){
            for(auto &value:buckets[i]) a[index++]=value;
        }
    }
}

基数排序

//基数排序：最坏时间复杂度：O(n*k),最好时间复杂度：O(n*k),平均时间复杂度：O(n*k),空间复杂度：O(n+k),稳定

int findKth(int num,int n){
    int power=1;
    for(int i=0;i<n;i++) power*=10;
    return (num%power)*10/power;
}

void RadixSort(int a[],int length){
    if(a==nullptr || length<=1) return;
    int maxA=a[0];
    for(int i=0;i<length;i++){
        if(a[i]>maxA) maxA=a[i];
    }

    int k=0;
    //cout<<maxA<<endl;
    while(maxA>0){
        ++k;
        maxA/=10;
    }
    //cout<<"k: "<<k<<endl;

    for(int i=1;i<=k;i++){
        int C[10]={0};
        int B[length];
        for(int j=0;j<length;j++){
            int d=findKth(a[j],i);
            ++C[d];
        }
        for(int j=1;j<10;j++){
            C[j]=C[j]+C[j-1];
        }

        for(int j=length-1;j>=0;j--){
            int d=findKth(a[j],i);
            --C[d];
            B[C[d]]=a[j];
        }

        for(int j=0;j<length;j++)
            a[j]=B[j];
    }
}

int main()
{
    int a[]={15,9,8,7,6,5,4,3,2,1,12,23,45};
    RadixSort(a,13);
    for(int i=0;i<13;i++) cout<<a[i]<<endl;
    return 0;
}

计数排序

基数排序：最坏时间复杂度：O(n+k),最好时间复杂度：O(n+k),平均时间复杂度：O(n+k),空间复杂度：O(n),稳定

#include<iostream>
using namespace std;
int findmax(int *a,int size)
{
	int max=0;
	int length=size;
	for(int i=1;i!=length;i++)
	{
		if(a[max]<a[i])
		max=i;
	}
	return a[max];
}
int* countsort(int *a,int size)
{
	int k=findmax(a,size)+1;
	int *c=new int[k];
	int length=size;
	
	for(int j=0;j!=k;j++)
		c[j]=0;
	for(int i=0;i!=length;i++)
		c[a[i]]=c[a[i]]+1;
	for(int i=1;i!=k;i++)
		c[i]=c[i]+c[i-1];
	int *b=new int[length];
	for(int i=length-1;i>=0;i--)
	{
		b[c[a[i]]-1]=a[i];
		c[a[i]]=c[a[i]]-1;
	}
	return b;
	delete [] c;
}