数据结构之排序

北航软件工程专业考研991数据结构总结：

八、内排序
1．排序的基本概念，各种内排序方法的基本原理和特点，包括排序过程中进行的元素之间的比较次数，排序总趟数、排序稳定性以及时间复杂度与空间复杂度计算；
2．插入排序法(含折半插入排序法)；
3．选择排序法；
4．(起)泡排序法；
5．谢尔(Shell)排序法；
6．快速排序法；
7．堆积(Heap)排序法，包括堆积的定义与构造；

1、插入排序法

原理：第i趟将第 i+1 个元素插入到前面已经排序的 i 个元素序列中，并保持排序

void InsertSort(int *a, int n)
{
    int i, j, temp;
    
    for(i = 1; i < n-1; i++)
    {
        temp = a[i];
        j = i-1;
        while(j >= 0 && a[j] > temp)    //依次向前比较，将大于i的数后移
            a[j+1] = a[j--];
            
        a[j+1] = temp;
    }
}

最好的情况下，需要比较n-1次，即已经排序好，时间复杂度就是O(n)
最坏的情况下，需要比较你n(n-1)/2次，即逆序排列，时间复杂度为O(n^2)

稳定排序

2、选择排序法

原理：第i趟排序，从后面的 n-i+1 个元素中选择一个最小的，放置到 n-i+1 个未排序元素的最前面

void SelectSort(int *a, int n)
{
    int i, j, d, temp;
    
    for(i = 0; i < n-1; i++)
    {
        d = i;        
        for(j = i + 1; j < n; j++)    //从后面的元素中找到最小的元素
        {
            if(a[j] < a[d])
                d = j;
        }
        if(d != i)
        {
            temp = a[i];
            a[i] = a[d];
            a[d] = temp;
        }
    }
}

无论好坏，都需要比较n(n-1)/2次，时间复杂度为O(n^2)
稳定排序

3、泡排序

原理：第i趟排序，将前面的 n-i+1 个元素从第一个开始左右比较，如果左边大于右边，则进行互换，否则不进行换序
      当没有出现换序的时候，则排序完成，或者只有第一个元素的时候排序完成
      
void BubbleSort(int *a, int n)
{
    int i, j, temp, flag;
    flag = 1;
    i = n-1;
    while(i > 0 && flag == 1)
    {
        flag = 0;
        for(j = 0; j < i; j++)
        {
            if(a[j] > a[j+1])
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                flag = 1;
            }
        }
        i--;
    }
}

当元素已经排序好的时候，不需要交换  比较次数为 n-1 时间复杂度O(n)
当元素没有排序时，至少交换一个
当元素第一个为最大，剩余的都是排序时，交换n-1次
最坏的情况下，比较次数为 n(n-1)/2 时间复杂度O(n^2)
适用于序列基本有序的情况下
稳定排序

*****************
前面的这3中排序简直就是玩
搞定后面的这些才牛逼呢
*****************

4、谢尔Shell排序  缩小增量排序法

设置一个间隔d，每隔间隔d对元素进行排序
然后缩小间隔d，继续进行排列
知道d < 1 排列完成

时间复杂度介于 nlog2n 到 n^2之间
最外层的趟数为log2n
非稳定排序

算法：

void SelectSort(int *a, int n)
{
    int i,j,d,temp, flag;
    d = n;
    while(d > 1)
    {
        d = d/2;
        do
        {
            for(i = 0; i < n - d; i++)
            {
                j = i + d;
                if(a[i] > a[j]
                {
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    flag = 1;
                }
            }
        }while{flag != 0);
    }
}

5、快速排序法

原理：确定一个比较元素，让所有大于该数的元素排列在它后面，小于它的数排列在它后面，在对长度大于1的前后子列进行递归运算

时间复杂度：O(nlog2n)

非稳定排序

算法步骤：

void QuickSort(int *a, int n)
{
    Quick(a, 0, n-1);
}

void Quick(int *a, int s, int t)
{
    int i, j, temp;
    if(s < t)
    {
        i = s;
        j = t+1;
        
        while(1)
        {
            do i++;
            while(!(a[s] < a[i] || i == t));
            
            do j--;
            while(!(a[s] > a[j]) || j == s);
            
            if(i < j)
            {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }else{
                break;
            }
        }
        
        temp = a[s];
        a[s] = a[j];
        a[j] = temp;
        
        Quick(a, s, j-1);
        Quick(a, j+1, t);
    }
}

两边出发  前小后大

6、堆积（Heap）排序，包括堆积的定义与构造

堆积的定义

使得一组序列满足 ki >= k2i 并且 ki >= k(2i+1)  大顶堆积

就是一个完全二叉树，使用顺序存储方式（数组）进行存储

排序：

首先将一个序列构造成大顶堆积，然后，将收尾互换，再将前 n-i+1 个元素构造大顶堆积，继续进行

问题是，如何构造大顶堆积呢？

先看一个左右序列已经是大顶堆积的，也就是一个大顶堆积首位互换之后的剩下的堆进行构造

将顶元素与子元素进行比较，如果小于最大的那个数，进行互换，再在子树中继续进行比较

这样，构造一个初始大顶堆积，可以从中间的 n/2 个元素开始，递减的调用上述方式即可

代码：

void Adjust(int *a, int i, int n)
{
    int j, temp;
    j = 2 * i;
    temp = a[i];
    while(j <= n)
    {
        if(j < n && a[j] < a[j+1])
            j++;
            
        if(temp > a[j])
            break;
            
        a[j/2] = a[j];    //将子树中较大的元素移到父树中去
        j = 2 * j;
    }
    a[j/2] = temp;
}

注意：上述是理论代码，不是C语言的可执行代码，因为C语言中，数组从1开始，所以，j和i的关系应该是 j = 2 * i + 1;  i = (j - 1)/2;

可执行的代码：

void Adjust(int *a, int i, int n)
{
    int j, temp;
    j = 2 * i + 1;
    temp = a[i];
    while(j <= n)
    {
        if(j < n && a[j] < a[j+1])
            j++;
            
        if(temp > a[j])
            break;
            
        a[(j-1)/2] = a[j];    //将子树中较大的元素移到父树中去
        j = 2 * j + 1;
    }
    a[(j-1)/2] = temp;
}

堆积排序主函数：

void HeapSort(int *a, int n)
{
    int i = 0;
    for(i = n / 2; i >= 1; i--)
    {
        Adjust(a, i, n);
    }
    
    for(i = n-1; i >= 1; i--)
    {
        int temp = a[i+1];
        a[i+1] = a[1];
        a[1] = temp;
        Adjust(a, 1, i);
    }
}

同样，这是理论的函数，C语言中的可执行函数如下：

void HeapSort(int *a, int n)
{
    int i = 0;
    for(i = (n-1) / 2; i >= 0; i--)
    {
        Adjust(a, i, n-1);
    }
    
    for(i = n-2; i >= 0; i--)
    {
        int temp = a[i + 1];
        a[i + 1] = a[0];
        a[0] = temp;
        Adjust(a, 0, i);
    }
}

非稳定  nlog2n

总结一下：

插入排序法
    
    最好的情况下，需要比较n-1次，即已经排序好，时间复杂度就是O(n)
    最坏的情况下，比较次数为n(n-1)/2，即逆序排列，时间复杂度O(n^2)
    稳定的排序
    
选择排序法

    O(n^2) 与好坏无关
    稳定排序

泡排序

    已经排序的情况下不需要交换
    最大的元素在首，其他排序，交换n-1次 
    稳定排序
    适用于序列基本有序的情况下
    
    
谢尔Shell排序

    需要一个间隙d，划分子列，
    介于 nlog2n 与 n^2之间
    不稳定排序
    循环嵌套三层

快速排序法

    选择一个元素作为比较依据，前大后小，两端出发
    nlog2n
    不稳定排序

堆积排序

    构造堆积
    nlog2n
    不稳定排序