排序算法归总

排序算法归总: 参考：http://blog.csdn.net/johnny_83/archive/2007/11/07/1871751.aspx 

排序知识：
一. 排序的分类
1. 内部排序：内部排序(简称内排序)，是带排序纪录存放在计算机内存中，并进行的排序过程。
2. 外部排序：指的是带排序纪录的数量很大，以致内存一次不能容纳全部纪录，在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法。
二. 排序的稳定性
如果排序前后相等数的先后位置不变，则为稳定排序，否则为不稳定排序。
三. 常用排序算法：

1.插入排序
1)直接插入排序(扑克排序)
算法复杂度：O(n^2)
void InsertSort(Type A[], int n)
{
    for(i = 1; i < n; i++)
    {
        tmp = A[i];
        for(j = i; j > 0 && A[j-1] > tmp; j--)
            A[j] = A[j-1];
        A[j] = tmp;
    }
}
2)希尔排序(缩小增量法)
属于插入类排序,将整个无序列分割成若干小的子序列分别进行插入排序 
排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止
算法复杂度: O(nlog(n))
void ShellSort(Type A[], int n)
{
    int i, j, increment;
    for(increment = n / 2; increment > 0; increment /= 2)
        for(i = increment; i < N; i++) //组内进行直接插入排序
        {
            tmp = A[i];
            for(j = i; j>= increment && A[j-increment] > tmp; j-= increment)
                A[j] = A[j-increment];
            A[j] = tmp;
        }
}

2. 选择排序
1)简单选择排序
算法复杂度：O(n^2)
void SelectSort(Type A[], int n)
{
    for(i = 0; i < n; ++i)
    {
        min = A[i];
        for(j = i + 1; j < n; j++)
            if(A[j] < min) min = A[j];
        A[i] = min;
    }
}
2)堆排序

3. 交换排序
1)冒泡排序
void BubbleSort(Type A[], int n)
{
    for(i = 0; i < n; i++)
        for(j = i + 1; j < n; j++)
            if(A[j-1] < A[j])
                A[j-1] <--> A[j];
}
2)快速排序
快速排序方法的实质是将一组关键字 [K1 ,K2 ,…,Kn ] 进行分区交换排序。
算法思路
a.以第一个关键字K1为控制字,将[K1 ,K2 ,…,Kn]分成两个子区,使左区所有关键字小于等于K1,右区所有关键字大于等于K1,最后控制字居两个子区中间的适当位置。在子区内数据尚处于无序状态。
b.对左,右区进行与第a步相类似的处理,又得到它的左子区和右子区,控制字居中。
c.重复第a,b步,直到左,右区处理完毕。
排序算法递归实现：
/*
  返回pivot的index
*/
int Partition(Type array[], int low, int high)
{
    pivot = array[low];
    while(low < high)
    {
        while(low < high && array[high] >= pivot) --high;
        array[low]<-->array[high];
        while(low < high && array[low] <= pivot) ++low;
        array[low]<-->array[high];
    }
    return low;
}
void QSort(Type array[], int low, int high)
{
    if(low < high)
    {
        pivot_index = Partition(array, low, high);
        QSort(array, low, pivot_index-1);
        QSort(array, pivot_index+1, high);
    }
}

4. 归并排序
两路归并排序算法思路：
a.把 n 个记录看成 n 个长度为 l 的有序子表；
b.进行两两归并使记录关键字有序，得到 n/2 个长度为 2 的有序子表；
c.重复第b步直到所有记录归并成一个长度为 n 的有序表为止。
void Merge (type array[], int p, int q, int r)
{
    int i,k;
    int begin1,end1,begin2,end2;
    int* temp = (int*)malloc((r-p)*sizeof(int));
    begin1 = p;
    end1 = q;
    begin2 = q+1;
    end2 = r;
    k = 0;
    while(begin1 <= end1 && begin2 <= end2)
    {
        if (array[begin1]<array[begin2])
        {
            temp[k] = array[begin1]; 
            begin1++;
        }
        else
        {
            temp[k] = array[begin2]; 
            begin2++;
        }
        k++;
    }
    while(begin1 < end1)
    {
        temp[k++] = array[begin1++];
    }
   
    while (begin2<end2)
    {
        temp[k++] = array[begin2++];
    }
    for (i=0; i<(r-p); i++)
    {
        array[p+i] = temp;
    }
    free(temp);
}
//归并排序
void MergeSort(type array[], unsigned int first, unsigned int last)
{
    int mid = 0;
    if(first < last)
    {
        mid = (first+last)/2;
        MergeSort (array, first, mid);
        MergeSort (array, mid+1, last);
        Merge (array, first, mid, last);
    }
}