经典排序方法及细节小结(1)

在数据结构的学习中，排序是我们要重点学习的一部分；在掌握几种经典排序算法的同时，我们还要能够根据实际中遇到的情况，结合它们的时间复杂度、空间复杂度、稳定性这几个方面选择最合适的算法。现针对常用的几种经典排序算法及易出错的地方总结如下:

1.插入排序

（1）直接插入排序

  直接插入排序是一种最简单的排序方法，其基本思路是：

①将一条记录插入到已排好的有序表中，从而得到一个大小加1的新有序表。

②每一步将一个待排序的数据元素，按其排序码的大小，插入到前面已经排好序的一组元素的合适位置上去

③循环①②步，直到元素全部插完为止。

 

假使按升序排序 当该序列为逆序时，每次调整都需将每个元素都需移到最前面，是最坏的情况，一共需移(n*(n-1))/2次；而当其序列基本有序,每个元素微调，一共就只需移动n次左右，便达到了最快的O(N)的复杂度。

时间复杂度：最好情况O(N)  最坏的情况O(N*N)  平均情况O(N*N)

容易看出若是相同的元素在排序前后，它们相对位置是没有变化的，所以

稳定性：稳定

代码如下：

 

void InsertSort(int* arr, size_t length)
{
    assert(arr);

    for(size_t i = 0; i< length -1; ++i)
    {
        int end = i;
        int tmp = arr[end + 1];
        while(end >= 0)
        {
            if(arr[end] <= tmp)
                break;
            else
            {
                arr[end+ 1] = arr[end];
                --end;
            }
        }
        arr[end + 1] = tmp;    

        //Print(arr, length);
    }

}

（2）希尔排序

希尔排序是直接插入排序的优化。优化的地方就在于它将待排序的序列分组进行插入排序，每组排好序后，整个序列就能达到基本有序；最后再进行一次直接插入排序即可。 如对下列序列排序：

具体思路：

①每隔gap大小个单位进行分组

②每个组内进行直接插入排序

③整体进行插入排序

注意：插入排序的快慢受序列有序程度影响，而希尔排序由于分组实现了插入排序使得整个序列希尔排序，整体提高了序列的有序度，提高了效率；同时，希尔排序再一个优化就是每次变化着选取gap来进行分组，这样每以gap分组排一次序后，就使序列更加有序，那么下一次再选一个gap分组排序就会更快了；选gap不妨以每次除以3的方式来选得，这样分得的组数就不会太多，或者太少（容易看出来，如果分得的组数太多，就和普通的插入排序没区别了；如果太少同样若如此）。

时间复杂度：最好情况:O(N)  最坏情况：O(N*N)  平均情况:O(log(N^1.3))

从前面容易知道在直接插入排序中，相同元素相对的位置排完序后不会发生改变；而希尔排序在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以稳定性：

稳定性：不稳定

实现代码：

void ShellSort(int* arr, size_t length)
{
    assert(arr && length > 0);
    
    int gap = length;
    while(gap > 1) //gap ==1 时，继续往后走，进行最后一次整体的插入排序
    {
        //gap不能太大 ，太大使得分组太少，和普通插入排序没多大区别
        //同理也不能分得太多。
        gap = gap/3 + 1;  //加1防止gap为0

        //预排 将它们分成多个组，组内进行插入排序；使整体基本有序
        for(size_t i = 0; i < length - gap; ++i)
        {
            int tail = i;
            int tmp = arr[tail+ gap];
            while(tail >= 0)
            {
                if(arr[tail] <= tmp)   //tail位置处值不大于待插入的值，跳出
                    break;
                else
                {
                    arr[tail+ gap] = arr[tail];
                    tail-= gap;    
                }
                
            }
            arr[tail + gap] = tmp;  
        }
        printf("gap %d:", gap);
        Print(arr, length);
    }

}
gap分趟排序结果：

 

 

 

2.交换排序

（1）冒泡排序

冒泡排序可能是我们最早接触的排序算法，尽管比较简单，但还是注意取有意义的变量名，同时还可以对其进行一点小的优化

思路：

①从第一个元素开始，相邻两元素比较大小，前面元素大(小)，两者就交换位置，直到最大(小)的元素排到了最后；

②在剩下的N -1个元素中继续操作①，直到最后剩下一个元素，结束算法

优化：设置一个标志符flag，flag初始值是0，如果在一趟遍历中有出现元素交换的情况，那就把flag置为1。一趟冒泡结束后，检查flag的值。如果flag依旧是0，那这一趟就没有元素交换位置，说明数组已经有序，循环结束。

时间复杂度：最好情况：O(N)  最坏情况：O(N*N) 平均情况：O(N*N)

稳定性：稳定

代码：

void BubbleSort(int* a, size_t length) //冒泡排序
{
    assert(a);

    size_t end = length - 1;
    size_t i = 0;

    for (; end > 0; --end)
    {
        size_t flag = 0;
        for (i = 0; i < end; ++i)
        {
            if (a[i] > a[i + 1])
            {
                Swap(&a[i], &a[i + 1]);
                flag = 1;
            }
        }

        if (0 == flag)   //冒泡一趟，没有发生一次交换，序列有序
            break;
    }
}

（2）快速排序

基本思想就是递归分治，假设要排升序，选取一个标准key，将比key小的全部放到key的左边，将比key大的全部放到key右边；确定了key位置，再以这个位置为界限划分左右子区间，依次往后递归。

这里比较困难的地方其实就是实现每一次的单趟排序。总结下来，有以下3中方法来实现单趟排序（个人感觉难度依次往后增加）

(1)挖坑法

思路：

①假使把数组首元素值作基准key，此时数组第一个位置a[left]就相当于一个‘坑’。

②设置两个指针begin和end分别指向数组的首、尾元素。从end开始向左找到一个比key小的值，用它将begin处值覆盖，相当于填‘坑’

③再从begin处往右找一个比key大的值，用其覆盖end处的值，相当于再把右边 ‘坑’填上

④重复②③，begin=end时结束，最后将最后一个‘坑’填上。

如对{5,1,9,3,6,8,0,2,7,5}序列排序的单趟排序过程如图：

 

int PartSort1(int* arr, int left, int right)
{
    int tmp= arr[left];  //保存key值
    int begin = left;
    int end = right;
    while(begin < end)
    {
        while(begin < end && arr[end] >= tmp)  //找到比key小
            --end;
        arr[begin] = arr[end];

        while(begin < end && arr[begin] <= tmp) //找到比key大
            ++begin;
        arr[end] = arr[begin];
    }
    arr[begin] = tmp;   //填上最后留下的坑
    return begin;
}

 

 

(2)左右指针法

思路：

①设置两个指针begin和end分别指向数组的首、尾元素，假使选第一个值作为基准值key。

②end依次往左查找比key小的值(先从end处往左找很关键！)，begin依次往右查找比key大的值，都找到后就交换两者的值

③继续②至begin = end结束，最后将第一个位置和begin、end最后停下位置处的两个值交换。

注意：

（1）之所以要先从end处往左边找，是由选取的基准值key的位置决定的。如针对序列{6,8,0,2,7},选6为基准key，由于先从end往左找，最后begin、end会在小于key的位置停下 即{6,2,0,8,7} 中'0'的位置；而若先从左边往右找，最后则会停在比key大的位置上 即新序列{6,2,0,8,7}‘8’的位置，最后将6 和 8交换就会出现问题。

（2）基准值key是可以随机选择的。但要考虑到一个问题。随机选择的key值位置如果不是在两端的话，那么实现排序到底是先从begin往右找 还是先从end往左找呢？这有存在问题了，以上面的序列进行分析：

①若选2为key

  begin end最后停下位置在选的key的左边，因为先从begin往右找，两指针最后会在大于key的位置处停下，故先从begin往右找是不会出错。

②而序列改成{6,7,0,2,8}  此时若选'7'为key，

最后begin end停下位置在key的右边，因为先从end往左找，所以两指针最后会在比较码比key小的位置停下，先从end往右找正确。

所以先从哪边找，要看两指针最后停下的地方是在选定key的位置的左还是右。此处key的位置靠左，所以最后两指针很有可能在其右边停下；而当选定的基准key的位置在序列中间的某个地方时，最后两指针停在那？这就和黑洞样，不得而知了~（说起黑洞，今天得到消息 霍金老先生去了。世界本源无穷尽，我们报以无尽的想象，奈何还是半途终于肉体的结束，）。额....跑远了   继续

细节处理：

比较细节的一步就是先将选的基准key换到最左边位置(或者最右边）这样便可以确定最后两指针停下的位置 避免掉到坑里了。

代码如下：

 

//左右指针交换法
int PartSort2(int* arr, int left, int right)
{
    //int key = arr[left];
    //三数取中法选取key值
    //int mid = left + ((right - left)>>1);
    //int key = GetMidNum(arr[left], arr[mid], arr[right]);

    //随机数法选key
    srand(time(NULL));
    int index = rand()%(right - left + 1);
    int key = arr[left + index];
    Swap(&arr[left], &arr[left + index]);  //细节问题

    int begin = left;
    int end = right;
    
    while(begin < end)
    {
        while(begin < end && arr[end] >= key)   //从右往左找 直到找到比key小的
            --end;
        while(begin < end && arr[begin] <= key)   //从左往右找 直到找到比key大的
            ++begin;
        Swap(&arr[begin] , &arr[end]);
    }
    //begin  end停下位置处值比key小
    Swap(&arr[begin], &arr[left]);  
    return begin;
}

 

 

（3）前后指针法

思路：( 假使排升序)

①选最右边的值作为基准key，设置两个指针cur prev,cur指向开头，prev指向前一个值。

②cur prev依次朝一个方向走，每当cur向后找到比较码比key小的位置，prev找比较码不小于key的位置，交换prev cur处的值

③当cur走到最右边时结束循环，交换最右边和prev+1位置处的值

注意：

1.  prev cur是同时往后面走。cur每走过一个比较码大于key的位置就让prev停一次，当cur再走到一个关键码比key小的位置时，prev就恰好在第一个比较码比key大的位置(相当于左边第一个待交换的位置)

2. 由于只有当cur每次走过位置的比较码比key小，prev才往后走；而选arr[right]作key值，故prev最后一定在比较码不小于key的位置停下。因此才有步骤③

（这样这个过程不太好理解，建议将排序的数组定义成全局数组放置开头，在VS等调试器下仔细查看交换过程）

代码：

 

//前后指针法      //实现单链表的快排
int PartSort3(int* arr, int left , int right)
{
    int prev = left -1;
    int cur = left;
    int key = arr[right] ; //选取一个标准
    while(cur < right)
    {
        if(arr[cur] < key)  //cur对应值小于key prev紧随其后
        {
            ++prev;
            if(prev != cur)  //cur对应值>= key，prev不动 cur继续往后找比key小的位置
                Swap(&arr[cur], &arr[prev]);   //然后交换prev cur两个位置值
        }
        ++cur;                          
    }
    Swap(&arr[++prev], &arr[right]);  
    return prev;
}

 ps:单链表的快速排序单趟划分能用此种思路。

 

快排采用了分治思想，用递归里天然的函数栈帧来实现，于是自然就会想到它的非递归实现

快排非递归

用栈来保存每次分治的区间坐标

思路：

①先将最初始的区间坐标压入栈内

②从栈里获得排序序列的区间，再将划分的来到两个子区间压入栈内，当区间长度为1时停止压栈

③重复步骤②，直到栈为空时结束循环

代码：

void QuickSortNonR(int* arr, int left, int right)
{
    assert(arr);
    if(left >= right)
        return;

    Stack s;
    StackInit(&s);
    StackPush(&s, left);
    StackPush(&s, right);
    while(StackEmpty(&s) != 0)  //
    {
        int end = StackTop(&s);
        StackPop(&s);
        int begin = StackTop(&s);
        StackPop(&s);

        int div = PartSort3(arr, begin, end);
        if(begin < div -1)   /左/区间长度大于1
        {
            StackPush(&s, begin);
            StackPush(&s, div -1);
        }
        if(end > div +1)  //右区间长度大于1
        {
            StackPush(&s, div+ 1);
            StackPush(&s, end);
        }
    }
}

 

快排的优化

①随机数法：选key时是有可能每次都选到区间的边界值，比如对一个降序序列进行升序排序，每次选得的key就十分尴尬了。随机数法每次随机的选择一个位置的值作key值，这从概率上来讲会提高排序的效率就不言而喻了。

 

但是即便如此，还是有可能会选到区间两端的值作key，于是又有了下面一种选key的方法

②取中位数法：将区间两端的值和中间位置处的值进行比较，取大小不大不小的数(中位数)作key. 这样进一步提高了效率

 

③小区间法：切割区间时，当区间内元素数量比较少时就不用切割区间了（递归太深影响效率），这时候就直接对这个区间采用直接插入法，可以进一步提高算法效率。

 

 

 

如果每次选取的key值大小都恰好是序列里中间的值时，那么划分的子区间连接起来就像一颗二叉树一样，

时间复杂度：最好情况：O(NlogN)     最坏：O(N*N)   平均： O(NlogN)

空间复杂度：最好情况：O(logN)   最坏：O(N)  (退化为冒泡排序)

稳定性：不稳定

 

 

说了这么些，经典的排序算法还有选择排序   归并排序    计数排序 等这么几个排序算法，这里限于篇幅，就下一篇再小结。

同时哪里有不对，也希望能给我指出。乐意讨论~~