关于排序算法（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 
#include 
#include 
#include 
#include 
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;ia[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]&&leftchilda[cur]&&rightchild=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=key&&lefta[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;ia[j]){
                min=j;
            }
        }

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

    }

}

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

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

}

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

    while(gap0){

        for(int i=gap;i=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