数据结构（第九章~>第十章）

排序
一.冒泡排序：
简单的来说，冒泡排序就是大的往下沉，小的往上浮，沉浮的过程其实就是比较大小进行交换的过程。

void bubble_up_Sort(int arr[],int n){
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1-i;j++){
            if(arr[j]>arr[j+1]){
                int t;
                t=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=t;
            }
        }
    }
}

二.选择排序：
选择排序其实就是向一段序列中找一个最小的元素，然后输出，接着往后面的元素继续找最小的元素，如此循环即可。

void select_Sort(int arr[],int n){
    for(i=0;i<n;i++){
        int min=i;
        for(int j=i+1;j<n;j++){
            if(arr[min]>arr[j]){
                min=j;
            }
        }
        if(min!=i){
            int t=arr[min];
            arr[min]=arr[i];
            arr[i]=t;
        }
    }
}

三.插入排序：
打过扑克牌的人都知道，要将一首牌牌好序，就得从头抽一张牌出来，然后插在一个比它小的的前面，比它大的的后面就行。

void insert_Sort(int arr[],int n){
    for(int i=0;i<n;i++){
        int temp=arr[i];
        for(int j=i;j>=0&&arr[j-1]>temp;j--){
            arr[j]=arr[j-1];
        }
        arr[j]=temp;
    }
}

四.希尔排序：
希尔排序，其实就是对插入排序的一种优化，多了一种希尔增量序列，按照一定的间隔排序，代码其实和插入差不多，只是多了一层循环

void shell_Sort(int arr[],int n){
    for(int k=n/2;k>0;k=k/2){
        for(int i=k;i<n;i++){
            int temp=arr[i];
            for(int j=i;j>=k&&arr[j-k]>temp;j-=k){
                arr[j]=arr[j-k];
            }
            arr[j]=temp;
        }
    }
}

五.桶排：
桶排其实就是插旗子，我们把下标看数，如果元素的等于下标，就该桶就加一，但是前提是全部的桶是为空的，这样就方便记录数量。

void bucket_Sort(int arr[],int n){
    memset(b,0,sizeof(b));
    for(int i=0;i<n;i++){
        b[arr[i]]++;
    }
    for(i=0;i<1000;i++){
       for(int j=0;j<b[i];j++){
           printf("%d ",i);
       }
    }
}

六.归并排序（分与治）:
分：就是将一无序的序列运用二分思想从中分开，直到每组只有一个元素的时候，我们可以将它看成有序的，不用进行处理了。但如果一组数中有2个元素，将它们排序，小在左，大在右。如果超过2个元素，就继续进行递归拆分。
治：其实就是将拆分的元素合并起来，组成一个有序的序列。

oid merge_Sort(int arr[],int left,int right)//分
{

    if(left<right)
    {
        int mid=(right+left)/2;
        MergeSort(arr,left,mid);
        MergeSort(arr,mid+1,right);
        Merge(arr,left,right,mid);
    }
}
void Merge(int arr[],int left,int right,int mid)//治
{
    int i=0,j,k,l;
    int temp[right-left+1];
    k=left,l=mid+1;
    while(k<=mid&&l<=right)
    {
        if(arr[k]>arr[l])
        {
            temp[i++]=arr[l++];
        }
        else
            temp[i++]=arr[k++];
    }
    while(k<=mid)
    {
        temp[i++]=arr[k++];
    }
    while(l<=right)
    {
        temp[i++]=arr[l++];
    }
    i=0;
    for(j=left; j<=right; j++)
        arr[j]=temp[i++];
}

七.快速排序：
快速排序其实，也是分与治，就是随便从序列中找一个哨兵，然后从前面找一个比它大的数，从后面找一个比它小的数，然后交换，就一直这样分，知道两者相遇，相遇之后就将该哨兵与该数交换。

void quick_sort(int left,int right)
{
    int i,j,t,temp;
    if(left>right)
        return;
    temp=a[left];
    i=left;
    j=right;
    while(i!=j)
    {
        while(arr[j]>=temp&&i<j)
            j--;
        while(arr[i]<=temp&&i<j)
            i++;
        if(i<j)
        {
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    arr[left]=arr[i];
    arr[i]=temp;
    quicksort(left,i-1);
    quicksort(i+1,right);
    return;
}