排序算法总结（C++实现方式）

排序算法总结（C++实现方式）

基数排序没写，其中我写的桶排序是一个桶有多个元素，每个桶再进行插入排序，简单的桶排序只有一个元素，用散列函数映射，然后再依次取出，所以时间复杂度是O(n+k),n为个数，k为最大值。

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

//冒泡排序，两两交换，共n-1趟,i趟之后，数组最后i个元素已排好序
void bubbleSort(vector<int>&A){//O(n^2),稳定,适用数组
    int size=A.size();
    bool flag=false;
    while(!flag){
        flag=true;
        for(int i=1;i<size;i++){
            if(A[i]<A[i-1]){
                swap(A[i],A[i-1]);
                flag=false;
            }
        }
        size--;
    }
}

//选择排序，从数组无序区间[0,j]选择最大，放到j处，[j,size)有序
void selectSort(vector<int>&A){//O(n^2),数组(不稳定)，链表（稳定）
    int size=A.size();
    int i,j,maxOne;
    for(j=size-1;j>0;j--){
        maxOne=j;
        for(i=0;i<=j;i++){
            if(A[i]>A[maxOne])
                maxOne=i;    
        }
        swap(A[maxOne],A[j]);
    }
}

//插入排序，将A[i]取出，在有序区间[0,i]找到合适位置放下
void insertSort(vector<int>&A){//O(n^2),适用数组、链表，都是稳定
    int size=A.size();
    for(int i=1;i<size;i++){
        int j=i-1;
        int key=A[i];
        while(j>=0&&key<A[j]){
            A[j+1]=A[j];
            j--;
        }
        A[j+1]=key;
    }
}

//希尔排序,平均O(nlg^2n),最坏O(n^2)
void shellSort(vector<int>&A){
    int size=A.size();
    for(int gap=size/2;gap>0;gap=gap/2){
        for(int i=gap;i<size;i++){
            int key=A[i];
            int j=i-gap;
            while(j>=0&&key<A[j]){
                A[j+gap]=A[j];
                j=j-gap;
            }
            A[j+gap]=key;
        }
    }
}

//最大堆排序,逻辑上是完全二叉树，物理上是数组，自己建堆和维护，O(lgn)，不稳定
void percolateDown(vector<int>&A,int i,int size){
    int lChild=2*i+1;int rChild=2*i+2;
    int maxOne=i;
    if(lChild<size&&A[lChild]>A[maxOne])    maxOne=lChild;
    if(rChild<size&&A[rChild]>A[maxOne])    maxOne=rChild;
    if(maxOne!=i){
        swap(A[maxOne],A[i]);
        percolateDown(A,maxOne,size);
    }
}

void percolateUp(vector<int>&A,int i){
    while(i>0){
        int parent=(i-1)/2;
        if(A[parent]>A[i])  break;
        swap(A[parent],A[i]);
        i=parent;
    }
}

void heapify(vector<int>&A){
    int size=A.size();
    for(int i=size/2;i>=0;i--){
       percolateDown(A,i,size); 
    }
}

void heapSort(vector<int>&A){
    heapify(A);
    int size=A.size();
    int j=size;
    for(int i=0;i<size;i++){
        swap(A[0],A[--j]);
        percolateDown(A,0,j);
    }
}

//快速排序,O(nlgn),不稳定，适用数组,最坏O(n^2)
int partition(vector<int>&A,int lo,int hi){
    swap(A[lo],A[lo+rand()%(hi-lo+1)]);
    int flag=lo;
    int privot=A[lo];
    while(lo<hi){
        while(lo<hi&&privot<=A[hi])
            hi--;
        // A[lo]=A[hi];
        while(lo<hi&&privot>=A[lo])
            lo++;
        // A[hi]=A[lo];  
        swap(A[lo],A[hi]);
    }
    swap(A[flag],A[lo]);
    return lo;
}
void quickSort(vector<int>&A,int lo,int hi){
    if(hi-lo<=1)    return ;
    int mi=partition(A,lo,hi-1);
    quickSort(A,lo,mi);
    quickSort(A,mi+1,hi); 

}

//归并排序， O(ngn),稳定
void merge(vector<int>&A,int lo,int mi,int hi){
    vector<int>B;
    for(int i=lo;i<mi;i++)
        B.push_back(A[i]);
    int i=lo,j=mi,k=0;
    while(k<(mi-lo)||j<hi){
       if(k<(mi-lo)&&(j>=hi||B[k]<=A[j])){
           A[i++]=B[k++];
       } 
       if(j<hi&&(k>=(mi-lo)||A[j]<B[k])){
           A[i++]=A[j++];
       }
    }
}
void mergeSort(vector<int>&A,int lo,int hi){
    if(hi-lo<=1)    return;
    int mi=lo+(hi-lo)/2;
    mergeSort(A,lo,mi);
    mergeSort(A,mi,hi);
    merge(A,lo,mi,hi);
}

//计数排序，稳定,O(n+k)，空间O(k),k为最大值，n为待排序树的个数
void countSort(vector<int>&A){
    int size=A.size();
    if(size==0) return;
    int maxValue=A[0];
    for(int i=0;i<size;i++){//找出带排序数中最大的值
        maxValue=max(maxValue,A[i]);
    }
    vector<int> count(maxValue+1);//分配maxValue+1大小的数组，
    for(int j=0;j<size;j++){//count[i]储存i出现的次数
        count[A[j]]++;
    }
    for(int k=1;k<maxValue+1;k++){
        count[k]=count[k-1]+count[k];//count[i]储存小于等于i的个数
    }
    int index=0;
    vector<int>B(size,0);
    for(int i=0;i<size;i++){//遍历count数组，一次存入到A数组中
        B[count[A[i]]-1]=A[i];
        count[A[i]]--;
    }
    A=B;
}

//桶排序,
void bucketSort(vector<int>& A){
    int size=A.size();
    int minValue=A[0],maxValue=A[0];
    for(int i=0;i<size;i++){  //找出待排序中最大值、最小值
        if(A[i]>maxValue)
            maxValue=A[i];
        else if(A[i]<minValue)
            minValue=A[i];
    }

    //设置5个桶
    int bucketSize=5;
    vector<vector<int>> buckets(bucketSize,vector<int>());
    for(int j=0;j<size;j++){//每个桶放入相应的元素
       buckets[(A[j]-minValue)/maxValue].push_back(A[j]);
    }
    //每个桶进行插入排序
    int index=0;
    for(int k=0;k<bucketSize;k++){
        insertSort(buckets[k]);
        for(int m=0;m<buckets[k].size();m++)
            A[index++]=buckets[k][m];//将排好序的桶元素一次取出
    }

    //基数排序

}

int main(){
    vector<int>A {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>B {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>C {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>D {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>E {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>F {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>G {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>H {9,19,3,0,1,3,3,8,4,8,7,88,33};
    vector<int>I {9,19,3,0,1,3,3,8,4,8,7,88,33};

    cout<<"bubbleSort:"<<endl;
    bubbleSort(A);
    for(auto&i:A)   cout<<i<<'\t';
    cout<<endl;
    cout<<"selectSort:"<<endl;
    selectSort(B);
    for(auto&i:B)   cout<<i<<'\t';
    cout<<endl;
    cout<<"insertSort:"<<endl;
    insertSort(C);
    for(auto&i:C)   cout<<i<<'\t';
    cout<<endl;
    cout<<"heapSort:"<<endl;
    heapSort(D);
    for(auto&i:D)   cout<<i<<'\t';
    cout<<endl;
    cout<<"quickSort:"<<endl;
    quickSort(E,0,E.size());
    for(auto&i:E)   cout<<i<<'\t';
    cout<<endl;
    cout<<"mergeSort:"<<endl;
    mergeSort(F,0,F.size());
    for(auto&i:F)   cout<<i<<'\t';
    cout<<endl;
    cout<<"shellSort"<<endl;
    shellSort(G);
    for(auto&i:G)   cout<<i<<'\t';
    cout<<endl;
    cout<<"countSort"<<endl;
    countSort(H);
    for(auto&i:H)   cout<<i<<"\t";
    cout<<endl;
    cout<<"bucketSort"<<endl;
    bubbleSort(I);
    for(auto&i:I)   cout<<i<<"\t";
    system("pause");
    return 0;
}
在这里插入代码片

参考文献