主流排序算法——C++

开始代码：

#include<bits/stdc++.h>
using namespace std;        //初始化
void paw(int &a,int &b){    //交换
    t=a;a=b;b=t;
}int len(int[] k){          //长度
    return sizeof(k)/sizeof(k[0]);
}

冒泡排序：

void bubble_sort(int[] k){
    int p=len(k);
    for(int i=0;i<p-1;i++){
        for(int j=0;j<p-i-1;j+=1){
            if(k[j]>k[j+1]){
                paw(k[j],k[j+1]);
            }
        }
    }return ;
}

选择排序：

void select_sort(int[] k){
    int p=len(k);
    for(int i=0;i<p;i++){
        m=k[0];w=0;
        for(int j=i;j<p;j++){
            if(m<k[j]){
                m=k[j];w=j;
            }
        }paw(k[i],k[w]);
    }return ;
}

插入排序：

void insert_sort(int[] k){
    int p=len(k)
    for(int i=0;i<p;i++){
        for(int j=0;j<i;j++){
            if(k[j]<k[i]){
                paw(k[j],k[i]);
            }
        }
    }return ;
}

希尔排序：

void shell_sort(int arr[]){
    int n=len(arr);
    int gap=n/2;
    while(gap>0){
        for(int i=gap;i<n;i++) {
            int temp=arr[i];
            int j=i;
            while(j>=gap && arr[j-gap]>temp) {
                arr[j]=arr[j-gap];
                j-=gap;
            }
            arr[j]=temp;
        }gap/=2;
    }
}

快速排序：

int quick_par(int[] k,int start,int end){
    int mark=start;
    int pivot=k[0];
    for(int i=start;i<end;i++){
        if(k[i]<pivot){
            mark++;
            paw(k[i],k[mark]);
        }
    }k[0]=k[mark];
    k[mark]=pivot;
}void quick_sort(int[] k,int start,int end){
    if(start>=end){
        return ;
    }pivot=quick_par(k,start,end);
    quick_sort(k,start,p-1);
    quick_sort(k,p+1,end);
    return ;
}

归并排序：

int[] merge_par(int[] a,int[] b){
    int m=len(a),n=len(b);
    int i=0,j=0,p=0,k[m+n];
    while((i==m)&&(j==n)){
        while((a[i]<b[j])&&(i<=m)){
            k[p]=a[i];
            i++;
            p++;
        }while((a[i]>b[j])&&(j<=n)){
            k[p]=b[j];
            j++;
            p++;
        }
    }
}int[] merge_sort(int[] List,int start,int end){
    if(start==end){
        return List[start];
    }if(start>end){
        return {};
    }int p=(start+end)/2;
    int a[p-start]=merge_sort(List,start,p);
    int b[end-p-1]=merge_sort(List,p+1,end);
    return merge_par(a,b);
}

堆排序：

void heap_par(int parent,int length,int[] List){
    t=List[parent];
    child=2*parent+1;
    while(child<length){
        if((child+1<length)&&(List[child+1]>List[child])){
            child++;
        }if(temp>=List[child]){
            break;
        }array[parent]=array[child];
        parent=child;
        child=2*child+1;
    }List[parent]=temp;
    return ;
}void heap_sort(int[] List){
    for(int i=(len(List)-2)/2;i>=0;i--){
        heap_par(i,len(List),List);
    }for(int i=len(List)-1;i>0;i--){
        paw(List[i],List[0]);
        heap_par(0,i,List);
    }return ;
}

计数排序：

void count_sort(int[] List){
    int max=List[0],min=List[0];
    int p=len(List);
    for(int i=1;i<p;i++){
        if(List[i]>max){
            max=List[i];
        }if(List[i]<min){
            min=List[i];
        }
    }d=max-min;
    int array[d+1];
    for(int i=0;i<p;i++){
        array[List[i]-min]++;
    }for(int i=1;i<len(array);i++){
        array[i]+=array[i-1];
    }int temp[p];
    for(int i=0;i<p;i++){
        temp[--array[List[i]-min]]=List[i];
    }List=temp;
    return ;
}

桶排序：

void bucket_sort(double[] arr){
    double max=arr[0];double min=max;
    int p=len(arr);
    for(int i=1;i<p;i++){
        if(List[i]>max){
            max=List[i];
        }if(List[i]<min){
            min=List[i];
        }
    }int d=max-min;
    double array[p][p];
    int k[p];
    for(int i=0;i<p;i++){
        int num=(arr[i]-min)*(p-1)/d;
        int t=k[num]++;
        array[num][t]=arr[i];
    }for(int i=0;i<p;i++){
        heap_sort(array[i]);
    }double t[p];int r=0;
    for(int i=0;i<p;i++){
        for(int j=0;(j<p)&&(array[i][j]!=0);j++){
            t[r++]=array[i][j];
        }
    }arr=t;
    return ;
}

基数排序：

void bin_sort(int[] arr){
    int max=arr[0];
    int p=len(arr);
    for(int i=1;i<p;i++){
        if(arr[i]>max){
            max=arr[i];
        }
    }int k=1;
    while((1<<k)<max){
        k<<=1;
    }for(int i=0;i<k;i++){
        int t[2],temp[2][p];
        for(int j=0;j<p;j++){
            if((1<<i)&arr[i]==0){
                temp[0][t[0]++]=arr[j];
            }else{
                temp[1][t[1]++]=arr[j];
            }
        }int g[p],m=0;
        for(int j=0;j<2;j++){
            for(int k=0;(k<p)&&(array[j][k]!=0);k++){
                g[m++]=array[j][k];
            }
        }arr=g;
    }return ;
}