十大经典排序算法C++实现

#include <iostream>
#include <vector>

using namespace std;

//冒泡排序
void bubblesort(vector<int>& arr){
    for(int i=0;i<arr.size()-1;++i){
        for(int j=0;j<arr.size()-1-i;++j){
            if(arr[j]>arr[j+1]){
                int temp=arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=temp;
            }

        }
    }
}

//选择排序
void selectionsort(vector<int>& arr){
    int len=arr.size();
    
    for(int i=0;i<len-1;++i){
        int minidx=i;
        for(int j=i+1;j<len;++j){
            if(arr[j]<arr[minidx]) minidx=j;
        }
        int temp=arr[minidx];
        arr[minidx]=arr[i];
        arr[i]=temp;
    }
    
}

//插入排序
void insertionsort(vector<int>& arr){
    int indx,curr;
    
    for(int i=1;i<arr.size();++i){
        curr=arr[i];
        int j=i;
        while(j-1>=0&&arr[j-1]>curr){
            arr[j]=arr[j-1];
            --j;
        }  
        arr[j]=curr;
    }
}

//希尔排序
void shellsort(vector<int>& arr){
    //遍历希尔序列即可
    for(int gap=arr.size()/2;gap>0;gap=gap/2){
        for(int i=gap;i<arr.size();++i){
            int curr=arr[i];
            int j=i;
            while(j-gap>=0&&arr[j-gap]>curr){
                arr[j]=arr[j-gap];
                j-=gap;
            }
            arr[j]=curr;
        }
    }
}

//归并排序递归
void merge(vector<int>& arr,vector<int>& temparr,int lstart,int rstart,int rend){
    int num=rend-lstart;
    int ptr=lstart,lend=rstart;
    
    while(lstart<lend&&rstart<rend){
        if(arr[lstart]<arr[rstart]) temparr[ptr++]=arr[lstart++];
        else temparr[ptr++]=arr[rstart++];
    }
    
    /* 直接复制左边剩下的 */
    while(lstart<lend) temparr[ptr++]=arr[lstart++];
    /* 直接复制右边剩下的 */
    while(rstart<rend) temparr[ptr++]=arr[rstart++];
    /* 将有序的TmpA[]复制回A[] */
    for(int i=0;i<num;++i,--rend){
        arr[rend-1]=temparr[rend-1];
    }
}

void msort(vector<int>& arr,vector<int>& temparr,int start, int end){
    if(end-start==1) return;
    else{
        msort(arr,temparr,start,(start+end)/2);
        msort(arr,temparr,(start+end)/2,end);
        merge(arr,temparr,start,(start+end)/2,end);
    }
}

//接口
void mergesort_recursion(vector<int>& arr){
    vector<int> temparr(arr.size(),0);
    msort(arr,temparr,0,arr.size());
}

//归并排序非递归
void mergesortpass(vector<int>& arr,vector<int>& temparr,int length){
    /* 两两归并相邻有序子列 */
    int N=arr.size();
    int i=0;
    for(;i+2*length<N;i+=2*length){
        merge(arr,temparr,i,i+length,i+length*2);
    }
    
    /* 归并最后2个子列*/
    if(i+length<N) merge(arr,temparr,i,i+length,N);
    /* 最后只剩1个子列*/
    else{
        for(;i<N;++i)
            temparr[i]=arr[i];
    } 
}

void MergesortWitoutRecursion(vector<int>& arr){
    vector<int> temparr(arr.size(),0);
    int N=arr.size();
    int length=1;
    while(length>N){
        mergesortpass(arr, temparr,length);
        length*=2;
        mergesortpass(temparr,arr,length);
        length*=2;
    }
}


//快速排序
void MakeMedianQS(vector<int>& arr,int start,int end){
    int mididx=(start+end-1)/2;
    if(arr[start]>arr[mididx]) swap(arr[start],arr[mididx]);
    if(arr[start]>arr[end-1]) swap(arr[start],arr[end-1]);
    if(arr[mididx]>arr[end-1]) swap(arr[mididx],arr[end-1]);
    swap(arr[mididx],arr[end-2]);
}
void QuikSort(vector<int>& arr,int start,int end){
    int pivot,i,j;
    
    if(end-start>3){
        MakeMedianQS(arr,start,end);
        pivot=arr[end-2],i=start,j=end-2;
        while(1){
            while(arr[++i]<pivot);
            while(arr[--j]>pivot);
            if(i<j) swap(arr[i],arr[j]);
            else break;
        }
        
        swap(arr[i],arr[end-2]);
        
        QuikSort(arr,start,i);
        QuikSort(arr,i+1,end);
        return;
    }
    //纯快速排序版本
//     else if(end-start==3){
//         MakeMedianQS(arr,start,end);
//         return;
//     }
//     else if(end-start==2){
//         if(arr[start]>arr[start+1]) swap(arr[start],arr[start+1]);
//         return;
//     }
    else return;
    //快排加插入排序
    vector<int> temp(arr.begin()+start,arr.begin()+end);
    insertionsort(temp);
    for(int i=start;i<end;++i){
        arr[i]=temp[i-start];
    }
    
    
}
void Quik_Sort(vector<int>& arr){
    QuikSort(arr,0,arr.size());
}

//堆排序
void HeadAjust(vector<int>& arr,int parent,int size){
    int max=parent,left=2*parent+1,right=left+1;
    if(left<size&&arr[max]<arr[left]) max=left;
    if(right<size&&arr[max]<arr[right]) max=right;
    if(max==parent) return;
    else{
        swap(arr[max],arr[parent]);
        HeadAjust(arr,max,size);
    }
}

void HeapSort(vector<int>& arr){
    for(int i=arr.size()/2-1;i>=0;--i){
        HeadAjust(arr,i,arr.size());
    }

    for(int i=arr.size()-1;i>=0;--i){
        swap(arr[0],arr[i]);
        HeadAjust(arr,0,i);
    }
}

//基数排序
#define radix 10
#define maxdigit 4
typedef struct Node *NodePtr;
struct Node{
    Node(int a,NodePtr p=NULL):key(a),next(p){};
    int key;
    NodePtr next;
};

struct HeadNode{
    NodePtr head;
    NodePtr tail;
};
typedef struct HeadNode bucket[radix];

int getdigit(int num,int d){
    int result=0;
    for(int i=1;i<=d;++i){
        result=num%radix;
        num/=radix;
    }
    return result;
};

void BucketSort(vector<int>& arr){
    NodePtr List=NULL;
    //把arr放入list里面
    for(int i=0;i<arr.size();++i){
        NodePtr temp= new Node(arr[i],List);
        List=temp;
    }
    //初始化bucket
    bucket B;
    for(int i=0;i<radix;++i){
        B[i].head=B[i].tail=NULL;
    }
    for(int i=1;i<=maxdigit;++i){
        //将list中的数放入桶中
        int getnum;
        while(List){
            getnum=getdigit(List->key,i);
            if(B[getnum].head==NULL){
                B[getnum].head=B[getnum].tail=List;
            }
            else{
                B[getnum].tail->next=List;
                B[getnum].tail=List;
            }
            List=List->next;
        }
        //再把桶里的数放入list
        List=NULL;
        for(int j=radix-1;j>=0;--j){
            if(B[j].head!=NULL){
                B[j].tail->next=List;
                List=B[j].head;
                //清空桶
                B[j].head=B[j].tail=NULL;
            }
        }
    }
    for(int i=0;i<arr.size();++i){
        arr[i]=List->key;
        NodePtr temp=List;
        List=List->next;
        delete temp;
    }
}

int main(){
    int n=100;
    vector<int> vRank(n,0);
    for(int i=n,j=0;i>0;++j,--i){
        vRank[j]=i;
        cout<<i<<' ';
    }
    cout<<endl<<endl;;
    BucketSort(vRank);
    
    for(const auto& i:vRank){
        cout<<i<<' ';
    }
    
    cout<<endl;
    return 0;
}