关于排序算法（C实现）

2019.9.21-2019.9.23 回顾并重新学习了8个排序算法，并且在理解之后自己实现了一遍，全部通过测试（人工测试QAQ）

冒泡排序：相邻两两比较，大数往后沉

选择排序：选择出最小的元素，放在最前，每次比较出“当前最小的元素”放在前面已排序的序列的结尾

插入排序：从第二个元素开始，不断和前边的元素比较，该元素如果小，就插在“当前的最前”

希尔排序：将间隔先预定好，每个间隔内使用插入排序

快速排序：双指针。flag用三者取中得到，放在最right的地方。左右指针指向的元素和flag比较，进行left++,right--或交换

堆排序：建堆，最大的在堆顶，之后每次将最后的元素放在堆顶，再将当前最大的换在堆顶

归并排序：分治思想，先分块，直到每块一个元素，然后再一个个合并比较

基数排序：先个数位，再十位，将某一位同样大小的放在同一个“桶”里，然后各个桶比较，先个数位，再十位，每次比较之后更新相对位置，以此类推

PS.关于数组元素的交换，要传地址，而不是值。在定义swap函数时，要int swap(int &a,int &b),其内部以及在主函数中的调用都和往常的形式一样。当然也可以像我在下面代码实现的那样，swap(int*a,int*b)，只不过这时，swap内部以及主函数调用时的表现有些不一样，略麻烦。。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
int n;//数组长度,输入的....

void swap(int*a,int*b){//数组交换数据，要传地址！！！
    int c=*a;
    *a=*b;
    *b=c;
}


int jishu_getNumLength(int maxvalue){
    int i=0;
    while(maxvalue>0){
        maxvalue=maxvalue/10;
        i++;
    }
    return i;
}

int jishu_getMaxValue(int a[]){
    int temp=0;
    for(int i=0;i<n;i++){
        if(temp<a[i]){
            temp=a[i];
        }
    }
    return temp;
}

int jishu_getMaxDigit(int a[]){//得到最高位数,即最大数的位数
    int maxvalue=jishu_getMaxValue(a);
    int maxdigit=jishu_getNumLength(maxvalue);
    return maxdigit;
}
/*
int jishu_arrappend(int count[],int value){
    int c[1000000];
    memcpy(c,count,n+1);
    c[n-1]=value;//?????
    return c;
}
*/
int jishu_adjust(int a[],int maxdigit){
    int mod=10;
    int div=1;
    int cqqqq[100000];
    int pos=0;
    int count[10000]={-1};
    for(int i=0;i<maxdigit;i++,div=10*div,mod=10*mod){

        //int pos=0;
        for(int j=0;j++;j<n){
            int value=a[j];
            int tong=a[j]%mod/div+mod;

            //count[tong]=jishu_arrappend(count[tong],value);///
            count[tong]=value;
        }


        for(int k=0;k<n;k++){
           if(count[k]!=-1){
                cqqqq[pos++]=count[k];
           }
      //      a[pos]=count[k];
      //      pos++;


        }
    }
    return cqqqq;
}

int jishusort(int a[]){
    int maxdigit=jishu_getMaxDigit(a);
    return jishu_adjust(a,maxdigit);
}

void merge(int a[],int b[],int left,int mid,int right){
    int i=left;
    int j=mid+1;
    int k=left;
    while(i<=mid&&j<=right){
        if(a[i]<=a[j]){
            b[k]=a[i];
            i++;
            k++;
        }
        if(a[i]>a[j]){
            b[k]=a[j];
            j++;
            k++;
        }
    }
    while(i<=mid){
        b[k]=a[i];
        k++;
        i++;
    }
    while(j<=right){
        b[k]=a[j];
        k++;
        j++;
    }
}

void merge_sort(int a[],int b[],int left,int right){

    if(right>left){
        int mid=left+(right-left)/2;
        merge_sort(a,b,left,mid);
        merge_sort(a,b,mid+1,right);
        merge(a,b,left,mid,right);

        for(int i=left;i<=right;i++){
            a[i]=b[i];
        }
    }


}


void heapadjust(int a[],int index,int length){
    int leftchild=index*2+1;
    int rightchild=index*2+2;
    int cur=index;

    if(a[leftchild]>a[cur]&&leftchild<length){
        cur=leftchild;
    }
    if(a[rightchild]>a[cur]&&rightchild<length){
        cur=rightchild;
    }

    if(index!=cur){
        swap(&a[cur],&a[index]);
        heapadjust(a,cur,length);
    }
}

void buildheap(int a[],int length){
    for(int i=length/2;i>=0;i--){
        heapadjust(a,i,length);
    }
}

void heapsort(int a[],int length){
    int len=length;
    buildheap(a,len);
    for(int i=len-1;i>0;i--){//i 是堆的最后一个
        swap(&a[0],&a[i]);
        len--;
        heapadjust(a,0,len);
    }
}

int quick_findmidkey(int a[],int left,int right){
    int mid=left+(right-left)/2;


    if((mid<=left&&mid>=right)||(mid>=left&&mid<=right)){
        return mid;
    }
    else if((mid>=left&&left>=right)||(mid<=left&&left<=right)){
        return left;
    }
    else if((mid>=right&&right>=left)||(mid<=right&&right<=left)){
        return right;
    }
    return 0;
}
int quick_part(int a[],int left,int right){//快排的核心
    if(left<right){
        int mid=quick_findmidkey(a,left,right);

        //让mid作为key,key放在最右边
        swap(&a[right],& a[mid]);

        int key=a[right];
        int key_index=right;

        while(left<right){
            while(a[left]<=key&&left<right){
                left++;
            }
            while(a[right]>=key&&left<right){
                right--;
            }
            if(a[left] != a[right]&&left<right){
                swap(&a[right],& a[left]);

            }

        }

        swap(&a[left],& a[key_index]);
        return left;
    }
    return 0;
}

void quick_sort(int a[],int left,int right){//快排的核心的入口
    if(left<right){
        int div=quick_part(a,left,right);

        quick_sort(a,left,div-1);
        quick_sort(a,div+1,right);
    }

}


void bubble(int a[]){//冒泡排序
    //int len=sizeof(a)/sizeof(a[0]);
    for(int i=0;i<n;i++){
        bool flag=true;//用标志来记录这一轮是否进行了排序， 若没有进行排序，则证明已经全部排完，可以结束
        int temp=0;

        for(int j=0;j<n-1-i;j++){
            if(a[j]>a[j+1]){

                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                flag=false;
            }
        }
        if(flag==true){
            break;
        }

    }
}

void select(int a[]){//选择排序
    for(int i=0;i<n;i++){
        int min=i;
        int temp=0;

        for(int j=i+1;j<n;j++){
            if(a[min]>a[j]){
                min=j;
            }
        }

        temp=a[i];
        a[i]=a[min];
        a[min]=temp;

    }

}

void insertsort(int a[]){//插入排序，从第二个开始和前边的比，小的插在最前边
    for(int i=1;i<n;i++){
        int temp=a[i];
        int j=i;

        while(temp<a[j-1]&&j>0){
            a[j]=a[j-1];
            j--;
        }

        if(j!=i){
            a[j]=temp;
        }
    }

}

void xier(int a[]){
    int gap=1;

    while(gap<n){
        gap=gap*3+1;
    }

    while(gap>0){

        for(int i=gap;i<n;i++){
            int temp=a[i];
            int j=i-gap;

            while(temp<a[j]&&j>=0){
                a[j+gap]=a[j];
                j=j-gap;
            }

            a[j+gap]=temp;
        }
            gap=gap/3;
    }
}


int main()
{
    int beforesort[10000];
    int result[100000];
    scanf("%d",&n);
    int i=0;

    while(i<n){
        scanf("%d",&beforesort[i]);
        i++;
    }

    //各种排序调用

   // bubble(beforesort);//冒泡排序
  //  select(beforesort);//选择排序，选出最小的放在最前边
  //  insertsort(beforesort);//插入排序
  //  xier(beforesort);
    //quick_sort(beforesort,0,n-1);//快排，双指针，递归
    //heapsort(beforesort,n);//堆排序
    //merge_sort(beforesort,result,0,n-1);
    jishusort(beforesort);
    int j=0;
    while(j<n){

        printf("%d",result[j]);
        j++;
    }

/*交换的函数的尝试
    int a1[100]={8,1};
    swap(&a1[0],&a1[1]);//
    printf("%d %d",a1[0],a1[1]);*/
    return 0;
}