七大内排序

我们更加排序记录是否全部放置在内存中，将排序分为内排序和外排序，这里我们主要了解七个经典的内排序：插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序。

对于一个问题，选择哪种排序方法主要从以下两方面进行考虑：

　　1.所选排序方法的时间复杂度。

　　2.所选排序方法的稳定性。

对于一些问题，排序的稳定与否至关重要，因此我们有必要了介绍下排序的稳定性： 通俗的说，对于待排序序列a[]，若有 a[i] == a[j]，a[i]的位置在a[j]前面，若排序后a[i]的位置仍然在a[j]前面，那么这种排序稳定，否则即为不稳定排序。

1.插入排序：

　　基本操作：将一个记录，插入到已经排好序的有序表中，从而得到一个新的，记录数增加1的有序表。

　　最优时间复杂度：当序列已经为有序时，时间复杂度为O(n)

　　最差时间复杂度：当序列为逆序时，时间复杂度为O(n^2)

　　稳定性：稳定

　　代码:

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

2.希尔排序：

　　基本操作：希尔排序是对插入排序改进。把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止（这里的增量可以理解为下标间隔）。

　　最优时间复杂度：O(nlogn)

　　最差时间复杂度：O(n^2)

　　稳定性：不稳定

　　代码：

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

3.选择排序：

　　基本操作：在未排序的序列中找到一个最大/最小值，将其放在已排序的序列的末尾。

　　最优时间复杂度：O(n^2)

　　最差时间复杂度：O(n^2)

　　稳定性：稳定

　　代码：

//////////////选择排序////////////////
void select_sort(int a[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        int k = i;
        for(int j=i+1;j<n;j++)
        {
            if(a[j] < a[k])
            {
                k = j;
            }
        }
        swap(a[k],a[i]);
    }
}

4.堆排序：

　　基本操作：将待排序序列构造成一个堆，每次将堆首与堆尾交换并把堆的大小减一，并对交换后的堆进行维护。直至堆的大小为1。

　　最优时间复杂度：O(nlogn)

　　最差时间复杂度：O(nlogn)

　　稳定性：不稳定

　　代码：

/////////堆排序///////////
void heap_adjust(int a[],int root,int len) //维护堆
{
    int ls = root*2+1;
    int rs = root*2+2;
    if(ls < len)
    {
        int pos = ls;
        if(rs < len)
        {
            if(a[rs] > a[ls])
            {
                pos = rs;
            }
        }
        if(a[root] < a[pos])
        {
            swap(a[root],a[pos]);
            heap_adjust(a,pos,len);
        }
    }
}

void heap_sort(int a[],int n)
{
    for(int i=n/2; i>=0; i--)
        heap_adjust(a,i,n);

    for(int i=n-1; i>0; i--)
    {
        swap(a[0],a[i]);
        heap_adjust(a,0,--n);
    }
}

5.冒泡排序：

　　基本操作：重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

　　最优时间复杂度：O(n)

　　最差时间复杂度：O(n^2)

　　稳定性：稳定

　　代码：

//////////冒泡排序///////////////
void Bubble_sort(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        int flog = false;
        for(int j=n-1;j>i;j--)
        {
            if(a[j] < a[j-1])
            {
                swap(a[j],a[j-1]);
                flog = true;
            }
        }
        if(!flog)
            return;
    }
}

6.快速排序：

　　基本操作：找到一个基准数，将小于基准数的元素放在基准数的左边，大于基准数的元素放在基准数的右边，此时基准便处于“正确”的位置，接下来对基准数的左、右两部分进行同样的操作。

　　最优时间复杂度：大多数情况下时间复杂度为O(nlogn)

　　最差时间复杂度：当待排序序列的所有元素值一样时，时间复杂度为O(n^2)

　　稳定性：不稳定

　　代码：

void quick_sort(int a[],int l,int r)
{
    if(l >= r)
        return;
    int temp = a[l];
    int i = l;
    int j = r;
    while(i < j)
    {
        while(i<j && a[j]>temp)
            j--;
        if(i < j)
            a[i++] = a[j];
        while(i<j && a[i]<temp)
            i++;
        if(i<j)
            a[j--] = a[i];
    }
    a[i] = temp;

    quick_sort(a,l,i-1);
    quick_sort(a,i+1,r);
}

7.归并排序：

　　基本操作：采用分治的策略，并将已经排好序的两个序列通过归并操作，形成一个新的有序序列

　　最优时间复杂度：O(nlogn)

　　最差时间复杂度：O(nlogn)

　　稳定性：稳定

　　代码：

void Merge(int a[],int l,int mid,int r)
{
    int len1 = mid - l + 1;
    int len2 = r - mid;
    int *L = new int[len1];
    int *R = new int[len2];

    for(int i=0;i<len1;i++)
        L[i] = a[l+i];
    for(int i=0;i<len2;i++)
        R[i] = a[mid+1+i];

    int pos1 = 0;
    int pos2 = 0;
    int k = l;

    while(pos1<len1 && pos2<len2)
    {
        if(L[pos1] < R[pos2])
        {
            a[k++] = L[pos1++];
        }

        else
        {
            a[k++] = R[pos2++];
        }
    }

    while(pos1 < len1)
    {
        a[k++] = L[pos1++];
    }

    while(pos2 < len2)
    {
        a[k++] = L[pos2++];
    }
    delete []L;
    delete []R;
}

void Merge_sort(int a[],int l,int r)
{
    if(l >= r)
        return;
    int mid = (l+r)/2;
    Merge_sort(a,l,mid);
    Merge_sort(a,mid+1,r);
    Merge(a,l,mid,r);
}