几种内排序算法

      排序算法可以说是最基本的算法，再熟悉不过了。习惯了使用STL的sort函数，若要自己来实现几种排序方法，真的能够准确无误的写出来吗？（以下排序算法均默认从小到大排序）。

1.简单选择排序

      算法思想：每次从未排序数组中选择最小数，跟排序后它对应位置元素交换。

      时间复杂度：最好，平均，最坏都为O(n²)。

      适用：元素较少的数组。

void SelectSort(int a[],int length)
{
    int i,j;
    for(i=0;i<length;i++)
    {
        int small=i;
        for(j=i+1;j<length;j++)
        {
            if(a[j]<a[small])
            {
                small=j;
            }
        }
        swap(a[i],a[small]);
    }
}

2.直接插入排序

      算法思想：依次遍历数组，将当前元素插入到已排序好数组中。

      时间复杂度：最好O(n)，最坏O(n²)

      适用：基本有序数组。因为算法必须进行n-1次排序，若数组基本有序，每次之比较一次，移动元素两次。

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

3.冒泡排序

      算法思想：依次比较相邻两个元素，最大数沉底。

      时间复杂度：最好O(n)，最坏O(n²)。

      适用：基本有序的数组。若已有序，只需排序一次，比较n-1次。

void BubbleSort(int a[],int length)
{
    int i,j,last;
    i=length-1;
    while(i>0)
    {
        last=0;
        for(j=0;j<i;j++)
        {
            if(a[j]>a[j+1]) 
                swap(a[j],a[j+1]);
            last=j;
        }
        i=last;
    }
}

4.*快速排序

      算法思想：每次将待排数组分为两部分，一部分小于分割元素，一部分大于分割元素。

      时间复杂度：平均O(nlog₂n），空间复杂度O(n)。

      适用：偏爱基本无序数组，适合数组元素多。快速排序时目前最快的排序算法。

      改进：1.递归算法效率不如非递归算法，可以用栈保存子序列上下界来消除递归。也可以用队列消除递归。

               2.先对短的序列排序，长的子序列后排序。

void QuickSort(int a[],int left,int right)
{
    if(left<right)
    {
        int i=left;
        int j=right;
        do
        {
            do i++;while(a[i]<a[left]);
            do j--;while(a[j]>a[left]);
            if(i<j) swap(a[i],a[j]);
        }while(i<j);
        swap(a[left],a[j]);
        QuickSort(a,left,j);
        QuickSort(a,j+1,right);
    }
}

5.合并排序

       算法思想：数组元素两两合并成一个子序列，子序列继续两两合并。

       时间复杂度：O(nlog₂n),空间复杂度O(n)。

void Merge(int a[],int i1,int j1,int i2,int j2)
{
    int *Temp=new int[j2-i1+1];
    int i=i1,j=i2,k=0;
    while(i<=j1&&j<=j2)
    {
        if(a[i]<=a[j])
            Temp[k++]=a[i++];
        else Temp[k++]=a[j++];
    }
    while(i<=j1) Temp[k++]=a[i++];
    while(j<=j2) Temp[k++]=a[j++];
    for(i=0;i<k;i++)
        a[i1++]=Temp[i];
    delete[] Temp;
}
void MergeSort(int a[],int length)
{
    int i1,i2,j1,j2;
    int size=1;
    while(size<length)
    {
        i1=0;
        while(i1+size<length)
        {
            i2=i1+size;
            j1=i2-1;
            if(i2+size-1>length-1)
                j2=length-1;
            else
                j2=i2+size-1;
            Merge(a,i1,j1,i2,j2);
            i1=j2+1;
        }
        size*=2;
    }
}

6.堆排序

      算法思想：利用最大堆原理，将堆顶元素跟排序后它对应的位置元素交换。

      时间复杂度：O(nlog₂n)

void AdjustDown(int a[],int r,int j)
{
    int child=2*r+1;
    int temp=a[r];
    while(child<=j)
    {
        if((child<j)&&(a[child]<a[child+1]))
            child++;
        if(temp>=a[child])
            break;
        a[(child-1)/2]=a[child];
        child=2*child+1;
    }
    a[(child-1)/2]=temp;
}

void HeapSort(int a[],int length)
{
    int i;
    for(i=(length-2)/2;i>=0;i--)
        AdjustDown(a,i,length-1);
    for(i=length-1;i>0;i--)
    {
        swap(a[0],a[i]);
        AdjustDown(a,0,i-1);

    }
}