算法之排序

一：冒泡排序

void M_sort(long a[], long n)
{
    long i,j,flat = 0;
    //第一种写法
    /*
    for (i = 0; i < n - 1; i++)
    {
        for (j = 0; j < n - 1 - i; j++)
        {
            if (a[j] > a[j + 1])
                flat = 1;//改进版
                swap(a,j,j+1);
            }
        }
        if(flat == 0) break;
    }
    */
    //第二种写法
    for(i = n -1 ; i>0; i--)
    {
        for(j = 0;j < i ;j++)
        {
           
            if(a[j]>a[j+1])
            {
                 flat = 1;
                swap(a,j,j+1);
            }
        }
    if(flat == 0 ) break;
    }
}

二：插入排序

void X_sort(long a[],long n)
{
    long x,y;
    /*
    for(i = 1;i<n;i++)
    {
       long temp = a[i];  //摸下一张牌
        for(j = i;j>0 && a[j-1]>temp;j--)
        {
          
            a[j] = a[j-1]; 移动空位
        }
        a[j] = temp; 插入新位置
    }*/
    for(x = 1;x<n;x++)
    {
        for(y = x - 1 ; y >= 0 && a[y]>a[y+1];y--)
        {
            swap(a,y,y+1);
        }
    }
}

三：堆排序

void swap(long A[], int i, int j)
{
    long temp = A[i];
    A[i] = A[j];
    A[j] = temp;
} 
void PrecDown(long A[],int i , int N)
{
    int child,parent;
    int tmp = A[i];
    for(parent = i;2 * parent + 1 < N;parent = child)
    {
        child = 2 * parent + 1;
        if(child!=N-1 && A[child] < A[child + 1 ])
        {
            child++;
        }
        if(A[child]<=tmp)
        {
             break;    
        }else
        {
            A[parent] = A[child];
        }
    }
    A[parent] = tmp;   
}
void Heap_sort(long a[],int N) 
{
    int i ; 
    for( i  = N/2;i>=0;i--)
    {
        PrecDown(a,i,N); 
    }
    for(i = N-1;i>0;i--)
    {
        swap(a,0,i);
        PrecDown(a,0,i);
    }
}

四：归并排序

void Merge(long A[],long tmpA[],int L,int R,int RightEnd){
    // L = 左边元素开始位置 ，R = 右边元素开始位置 ，RightEnd = 右边结束终点位置
    int NumSize = RightEnd-L+1; // 元素个数
    int LeftEnd = R-1;  // 左边元素终点位置
    int tmp = L;  // tmp 数组开始位置
    while( L <= LeftEnd && R <= RightEnd ){
        if(A[L] <= A[R]) // 从小到大排序，选小的
            tmpA[tmp++] = A[L++];
        else
            tmpA[tmp++] = A[R++];
    }
    // 也许左没走完
    while( L <= LeftEnd )
        tmpA[tmp++] = A[L++];
    // 也许右边没走完
    while( R <= RightEnd)
        tmpA[tmp++] = A[R++];
    // 再导回 A ,tmp此时已经越界，所以要先减再用
    for(int i=0;i<NumSize;i++)
        A[RightEnd--] = tmpA[--tmp];
}

// 分治
void Msort(long A[],long tmpA[],int L,int RightEnd){
    if(L < RightEnd){
        int center = ( L + RightEnd )/2;
        Msort(A,tmpA,L,center);
        Msort(A,tmpA,center+1,RightEnd);
        Merge(A,tmpA,L,center+1,RightEnd);
    }
}

void Merge_sort(long A[],int N){
    long tmpA[N];
    Msort(A,tmpA,0,N-1);
}

五：选择排序

void X_sort(long a[],long n)
{
    //选择排序: 就是拿一个数字,比较还有没有比这个数小的，如果有,就交换一下数字
    long i , j ;
    for( i = 0; i < n;i++)
    {
        long targer = i;
        for(j = i +1;j<n;j++)
        {
            targer = a[targer]>a[j]?j:targer;
        }
        swap(a,i,targer);
    }

    
}

六：快速排序

void quick_sort(int a[], int L, int R)
{
    if(L >= R)
    {
        return;
    }
    int x = L,y = R;
    int key = a[x];
    while(x < y)
    {
        while(x < y && a[y]>=key)
        {
            y--;
        }
        a[x]= a[y];
        while(x < y && a[x] <= key)
        {
            x++;
        }
        a[y] = a[x];
    }
    a[x] = key;
    quick_sort(a,L,x-1);
    quick_sort(a,y+1,R);
}