7大排序算法小结

1,快速排序 :

快速排序具有神奇的排序效率，平均状况下它的时间复杂度为Ο(nlogn)，但它通常明显比其他Ο(nlogn)的算法更快。快速排序概括起来三步：找基准，通常为序列首尾元素；与基准比较后左右分区；递归。
Java代码：
public void QuickSort(int[] array )
{
    int i = 0 ;
    int j = array.length - 1;
    int k = array[0];
    while(i != j)
    {
        while(array[j] > k)
        {
            j--;
        }
        int temp = k;
        k = array[j];
        array[j] = temp;
        while (array[i] < k)
        {
            i++;
        }
        int temp1= k;
        k = array[i];
        array[i] = temp1;
    }
}

2,归并排序 :

归并排序采用分治法递归实现，单次排序实现将两个有序序序列合并成一个。步骤为：申请大小为两个已经排序序列之和的空间；设定两个指针分别指向序列的起始位置；比较两个指针处的元素，小的放入空间，并移动指针；重复前一步直到某一指针达到序列尾；将另一序列剩下的所有元素直接复制到合并序列尾；递归。
C语言实现：
void Merge(int *R,int low,int m,int high)
{
    int i=low,j=m+1,p=0;
    int *R1;
    R1=(int *)malloc((high-low+1)*sizeof(int));
    if(!R1) return;
    while(i<=m&&j<=high)
        R1[p++]=(R[i]<=R[j])?R[i++]:R[j++];
    while(i<=m)
        R1[p++]=R[i++];
    while(j<=high)
        R1[p++]=R[j++];
    for(p=0,i=low;i<=high;p++,i++)
        R[i]=R1[p];
}
void MergeSort(int R[],int low,int high)
{
    int mid;
    if(low<high)
    {
        mid=(low+high)/2;
        MergeSort(R,low,mid);
        MergeSort(R,mid+1,high);
        Merge(R,low,mid,high);
    }
}

3,堆排序 :

堆排序，先建一个大顶堆，将堆顶元素与序列中最后一个记录交换，然后重新将它调整为一个大顶堆，再将堆顶记录和第 n-1 个记录交换，如此反复直至排序结束。
大顶堆是一棵任一非叶结点的关键字均不小于其左右孩子(若存在)结点的关键字的完全二叉树
C语言实现：
// array是待调整的堆数组,i是待调整的数组元素的位置,nlength是数组的长度
void HeapAdjust(int array[], int i, int nLength)//本函数功能是：根据数组array构建大根堆
{
    int nChild;
    int nTemp;
    for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild)
    {
        // 子结点的位置=2*(父结点位置）+ 1
        nChild = 2 * i + 1;
        // 得到子结点中较大的结点
        if (nChild < nLength - 1 && array[nChild + 1] > array[nChild])
            ++nChild;
        // 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
        if (nTemp < array[nChild])
        {
            array[i]= array[nChild];
        }
        else　// 否则退出循环
        {
            break;
        }
        // 最后把需要调整的元素值放到合适的位置
        array[nChild]= nTemp;
    }
}
// 堆排序算法
void HeapSort(int array[], int length)
{
    // 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
    for (int i = length / 2 - 1; i >= 0; --i)
    {
        HeapAdjust(array, i, length);
    }
    // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
    for (int i = length - 1; i > 0; --i)
    {
        // 把第一个元素和当前的最后一个元素交换,
        // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
        Swap(&array[0], &array[i]);
        // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
        HeapAdjust(array, 0, i);
    }
}

4,选择排序 :

选择排序简单直观。其原理是：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，放到排序序列末尾。以此类推，直到所有元素均排序完毕。
Java语言实现：
void SelectSort(SeqList R)
{
    int i,j,k;//最小关键字所在的位置
    for(i=1;i<n;i++){//做第i趟排序(1≤i≤n-1)
        k=i；
        for(j=i+1;j<=n;j++) //在当前无序区R[j..n]中选key最小的记录R[k]
            if(R[j].key<R[k].key)
                k=j; //k记下目前找到的最小关键字所在的位置
        if(k!=i){ //交换R[i]和R[k]
            R[0]=R[i];R[i]=R[k];R[k]=R[0]; //R[0]作暂存单元
        } //endif
    } //endfor
} //SeleetSort

5,冒泡排序 :

冒泡排序是通过依次比较相邻两元素的大小，若逆序则交换，这样一趟将最大的那个先找出来，然后再对剩下的队列进行下一趟排序直到没有发生交换为完成。
C语言实现：
void bubble_sort(int array[],int n)
{
    int i,j,flag,temp;
    for(i = 0; i < n-1; i++)
    {
        flag = 1;//交换标志
        for(j = 0; j < n-i-1; j++)
        {
            if(array[j] > array[j+1])
            {
            temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
            flag = 0;
        }
    }
}

6,插入排序 :

插入排序，先在待排序列中选择第一个元素，在排序序列中从后至前比较，当先元素大于序列中元素时插入。然后重复以前步骤。
void InsertSort(char array[],unsigned int n)
{
    int i,j;
    int temp;
    for(i=1;i<n;i++)
    {
        temp = array[i];//store the original sorted array in temp
        for(j=i ; j>0 && temp < array[j-1] ; j--)//compare the new array with temp
        {
            array[j]=array[j-1];//all larger elements are moved one pot to the right
        }
        array[j]=temp;
    }
}

7,希尔排序 :

希尔排序是一种分组插入排序算法，它采用缩小增量方法对原序列进行分组，在组内实行直接插入排序直到增量＝1 。增量d的取法：d1<n且避免序列中的值(尤其是相邻的值)互为倍数
C＃语言实现：
public void Shell_Sort(int[] list)
{
    int inc;
    for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
    for (; inc > 0; inc /= 3)
    {
        for (int i = inc + 1; i <= list.Length; i += inc)
        {
            int t = list[i - 1];
            int j = i;
            while ((j > inc) && (list[j - inc - 1] > t))
            {
                list[j - 1] = list[j - inc - 1];
                j -= inc;
            }
            list[j - 1] = t;
        }
    }
}

<完>