排序算法

void merge_sort(int a[],int m ,int n)
{
    if( m+1 < n)
    {
        int mid = (m+n)/2;
        merge_sort(a,m,mid);
        merge_sort(a,mid,n);
        merge(a,m,mid,n);
    }
}


void merge(int a[],int m,int mid,int n)
{
    int i,j,k = 0;
    i = m;
    j = mid;
    int *b = (int*)malloc((n-m+1)*sizeof(int));
    for(i=0;i<n-m+1;i++)
        b[i] = 0;
    i = m;
    while(i < mid && j < n)
    {
        if(a[i] < a[j])
        {
            b[k] = a[i];
            k++;
            i++;
        }
        else
        {
            b[k] = a[j];
            k++;
            j++;
        }

    }
    while(i < mid)
    {
        b[k] = a[i];
        k++;
        i++;
    }

    while(j < n)
        b[k++] = a[j++];
    for(i=m;i<n;i++)
    {
        a[i] = b[i-m];
    }
    free(b);
}


int position(int a[],int m,int n)
{
    int i,j;
    int temp = a[m];
    j = n-1;
    i = m;
    while(i<j)
    {
        while(i<j && a[j] > temp)
            j--;
        if(i<j)
        {
            a[i] = a[j];
            i++;
        }
        while(i<j && a[i] < temp)
            i++;
        if(i<j)
        {
            a[j] = a[i];
            j--;
        }
    }
    a[i] = temp;
    return i;
}


void quick_sort(int a[],int m,int n)
{
    if(m < n)
    {
        int i;
        i = position(a,m,n);
        quick_sort(a,m,i);
        quick_sort(a,i+1,n);
    }
}


void heap_sort(int a[],int n)
{
    int i;
    built_heap(a,n);
    for(i=n;i>0;i--)
    {
        int temp = a[1];
        a[1] = a[i];
        a[i] = temp;
        adjust_heap(a,1,i-1);
    }
}


void built_heap(int a[],int n)
{
    int i;
    for(i=n/2;i>0;i--)
    {
        adjust_heap(a,i,n);
    }
}


void adjust_heap(int a[],int i,int n)
{
    int left = 2*i;
    int right = 2*i+1;
    int max = i;
    if(left <= n && a[left] > a[max])
    {
        max = left;
    }
    if(right <= n && a[right] > a[max])
    {
        max = right;
    }
    if(i != max)
    {
        int temp = a[max];
        a[max] = a[i];
        a[i] = temp;
        adjust_heap(a,max,n);
    }
}


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


void select_sort(int a[],int n)
{
    int i,j,min;
    for(i=0;i<n;i++)
    {
        min = i;
        for(j=i+1;j<n;j++)
        {
            if(a[j] < a[min])
                min = j;
        }
        int temp = a[i];
        a[i] = a[min];
        a[min] = temp;
    }
}


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


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