各种内部排序

这两天写了一下排序，整理一下。。。

代码比较乱，自己看的，不要拍我。。。

注意：不管怎么样，程序是写出来的！一定要写！你才能知道各种边界啊，小错误啊~

注意：操作数组下标和数组元素的区别！！！

插入排序

void insertsort(int *a, int n)
{
    if(a==NULL || n<=0)
        return;
    for(int i=1; i<n; i++)
    {
        for(int j=i; j>0; j--)
        {
            if(a[j]<a[j-1])
                swap(&a[j], &a[j-1]);
        }
    }
}

选择排序

void selectsort(int *a, int n)
{
    if(a==NULL || n<=0)
        return;
    int min;
    for(int i=0; i<n; i++)
    {
        min = i;
        for(int j=i+1; j<n; j++)
        {
            if(a[j]<a[min])
            {
                min = j;
            }
        }
        swap(&a[min],&a[i]);
    }
}

冒泡排序（跟插入排序有点像。。。）

void bubblesort(int a[], int n)
{
    if(a==NULL || n <= 0)
        return;
    for(int i=0; i<n; i++)
    {
        for(int j=1; j<n-i; j++)
        {
            if(a[j]<a[j-1])
                swap(&a[j], &a[j-1]);
        }
    }
}

希尔排序

void shellsort(int a[], int n)
{
    if(a==NULL || n<=0)
        return;
    int gap = n;
    int i, j;
    int temp;
    while(gap>1)
    {
        gap = gap/3+1;
        for(i=gap; i<n; i++)
        {
            if(a[i-gap]>a[i])
            {
                temp = a[i];
                for(j=i-gap; j>=0&&temp<a[j]; j-=gap)
                {
                    a[j+gap] = a[j];
                }
                a[j+gap] = temp;
            }
        }
    }
}

快速排序

快排有两种写法，主要是分区函数partition的不同：

　　一种是两个指针从开头往结尾走，注意区分大于枢纽的元素和小于枢纽的元素；

　　一种是两个指针分别从开头和结尾往中间走。

A：两个指针从开头往结尾走：

int partition(int *a, int m, int n)
{
    //使用头元素、尾元素和中间元素取三数中值作为枢纽
    int mid = (m+n)/2;
    if(a[mid]<a[n])
        swap(&a[mid], &a[n]);
    if(a[m]<a[n])
        swap(&a[m], &a[n]);
    if(a[mid]<a[m])
        swap(&a[mid], &a[m]);
    swap(&a[mid], &a[n]);
    int first_high = m-1;
    for(int i=m; i<n; i++)
    {
        if(a[i]<a[n])
        {
            first_high++;
            if(first_high!=i)
                swap(&a[i], &a[first_high]);
        }
    }
    first_high++;
    swap(&a[first_high], &a[n]);
    return first_high;
}

B：两个指针分别从开头和结尾往中间走：

int partition(int a[], int m, int n)
{
    int mid = (m+n)/2;
    if(a[mid]<a[n])
        swap(&a[mid], &a[n]);
    if(a[m]<a[n])
        swap(&a[m], &a[n]);
    if(a[mid]<a[m])
        swap(&a[mid], &a[m]);
    swap(&a[mid], &a[n]);
    int i=m;
    int j=n+1;
    while(1)
    {
        while(a[++i]<a[n]){}
        while(a[n]<a[--j]){}
        if(i<j)
            swap(&a[i], &a[j]);
        else
            break;
    }
    swap(&a[i], &a[n]);
    return i;
}

void quicksort(int a[], int m, int n)
{
    int pivot;
    if(m<n)
    {
        pivot = partition(a, m, n);
        quicksort(a, m, pivot-1);
        quicksort(a, pivot+1, n);
    }
}

归并排序

void merge(int a[], int b[], int left, int mid, int right)
{
    int i,j,k;
    i = left;
    k = left;
    j = mid+1;
    while( i<=mid&&j<=right)
    {         if(a[i]<=a[j])
            b[k++]=a[i++];
        else
            b[k++]=a[j++];
    }
    while(i<=mid){
        b[k++]=a[i++];
    }
    while(j<=right)
        b[k++]=a[j++];
　　　　//此处注意要复制，否则只对原来的数组操作，结果是错误的！
    for(i=left; i<k; i++)
        a[i]=b[i];
}
void mergesort(int a[], int b[], int left, int right)
{
    if(left<right)
    {
        int mid = (left+right)/2;
        mergesort(a, b, left, mid);
        mergesort(a, b, mid+1, right);
        merge(a, b, left, mid, right);
    }
}

堆排序

void heapify(int a[], int index, int length)
{
    int left = 2*index+1;
    int right = 2*index+2;
    int largest;
    if(left<length && a[left]>a[index])
        largest = left;
    else
        largest = index;
    if(right<length && a[right]>a[largest])
        largest = right;
    if(largest!=index)
    {
        swap(&a[largest], &a[index]);
        heapify(a, largest, length);
    }
}
void buildheap(int a[], int n)
{
    for(int i=n/2-1; i>=0; i--)
    {
        heapify(a, i, n);
    }
}
void heapsort(int a[], int n)
{
    buildheap(a, n);
    for(int i=n-1; i>=1; i--)
    {
       swap(&a[0], &a[i]);
       heapify(a, 0, i);
    }
}

over！