数据结构杂谈（一）浅谈基本排序算法

0.基本概念

记录：待排序的项目

关键词：决定排序结果

稳定性：相同关键词的记录保持原来的相对次序

1.1插入排序（Insertion Sort）

算法思想

一种简单直观的排序算法，工作原理是通过构建有序序列：对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

 

算法描述

具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找插入排序。

c++语言实现

void insertSort(MyArray &arr)
{
    for (int i = 1; i < arr.len();i++)
    {
        int current = i;
        while ((arr[current]>arr[current - 1]) && (current - 1) >= 0)
        {
            arr.swap(current, (current - 1));
            current--;
        }
    }
}

*注：为方便描述排序算法，使用了我自己做的数组类，代码请见最后。

算法分析

1.稳定的

2.最好情况：(n-1)

最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。

最坏情况：n(n-1)/2

3.最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次：第2个元素比较1次，第3个元素比较2次…第n个元素比较n-1次，求和为n(n-1)/2。

4.平均复杂度：O(n2)

平均来说插入排序算法复杂度为O(n2)。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。

1.2希尔排序

算法思想

也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

1.改进依据

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

2.算法思想

希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。

一个更好理解的希尔排序实现

数组表，将数组列在一个表中并对列排序（用插入排序）。重复这过程，不过每次用更长的列来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身仅仅对原数组进行排序（通过增加索引的步长，例如是用i += step_size而不是i++）。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以1步长进行排序（此时就是简单的插入排序了）。

c++语言实现

*注：这里使用的步长为每次除2（即为Donald Shell最早提出的版本）

void shellSort(MyArray &arr)
{
    int gap = arr.len() / 2;
    while (gap >= 1)
    {
        //对每组插入排序；
        for (int k = 0; k < gap; k++)
        {
            for (int i = 1+k; i < arr.len(); i += gap)
            {
                int current = i;
                while ((arr[current] > arr[current - gap]) && (current - gap) >= 0)
                {
                    arr.swap(current, (current - gap));
                    current -= gap;
                }
            }
        }
        gap /= 2;//by Donald Shell
    }
}

算法分析

1.不稳定

2.步长与复杂度

步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为插入排序，这就保证了数据一定会被排序。

Donald Shell最初建议步长选择为

并且对步长取半直到步长达到1。虽然这样取可以比

类的算法（插入排序）更好，但这样仍然有减少平均时间和最差时间的余地。可能希尔排序最重要的地方在于当用较小步长排序后，以前用的较大步长仍然是有序的。比如，如果一个数列以步长5进行了排序然后再以步长3进行排序，那么该数列不仅是以步长3有序，而且是以步长5有序。如果不是这样，那么算法在迭代过程中会打乱以前的顺序，那就不会以如此短的时间完成排序了。

已知的最好步长序列是由Sedgewick提出的(1, 5, 19, 41, 109,...)，该序列的项来自

和

这两个算式。这项研究也表明“比较在希尔排序中是最主要的操作，而不是交换。”用这样步长序列的希尔排序比插入排序要快，甚至在小数组中比快速排序和堆排序还快，但是在涉及大量数据时希尔排序还是比快速排序慢。

另一个在大数组中表现优异的步长序列是（斐波那契数列除去0和1将剩余的数以黄金分区比的两倍的幂进行运算得到的数列）：(1, 9, 34, 182, 836, 4025, 19001, 90358, 428481, 2034035, 9651787, 45806244, 217378076, 1031612713,…)

2.1冒泡排序（Bubble Sort）

算法思想

不断交换反序对:

是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法实现

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

c++语言实现

void bubbleSort(MyArray &arr)
{
    for (int i = 0; i < arr.len(); i++)
    {
        for (int j = arr.len()-1; j >= i+1; j--)
        {
            if (arr[j] > arr[j - 1])
                arr.swap(j, j - 1);
        }
    }
}

算法分析

1.稳定

2.复杂度

冒泡排序对

个项目需要O(

)的比较次数，且可以原地排序。尽管这个算法是最简单了解和实现的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。

冒泡排序是与插入排序拥有相等的运行时间，但是两种算法在需要的交换次数却很大地不同。在最好的情况，冒泡排序需要

次交换，而插入排序只要最多

交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地运行（

），而插入排序在这个例子只需要

个运算。因此很多现代的算法教科书避免使用冒泡排序，而用插入排序替换之。冒泡排序如果能在内部循环第一次运行时，使用一个旗标来表示有无需要交换的可能，也可以把最好的复杂度降低到

。在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。有时候称为鸡尾酒排序，因为算法会从数列的一端到另一端之间穿梭往返。

一个对冒泡有趣的改进地精排序请移步我的下一篇文章 http://www.cnblogs.com/yatesxu/p/5402127.html

2.2快速排序 Quick Sort

算法思想

不断交换反序对：使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

算法实现

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法分析

1.不稳定

2.复杂度

在平均状况下，排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

一个实例

c++语言实现

void quickSortProcess(MyArray &arr, int m, int n)
{
    if (m < n)
    {
        int i = m;
        int j = n;
        while (i <= j)
        {
            while ((arr[m] >= arr[i]) && (i <=n))
                i++;
            while ((arr[m] < arr[j]) && (j >=m + 1))
                j--;
            if (i < j)
                arr.swap(i, j);
        }
        arr.swap(m, j);
        quickSortProcess(arr, m, j - 1);
        quickSortProcess(arr, j + 1, n);
    }
}
void quickSort(MyArray &arr)
{
    quickSortProcess(arr, 0, arr.len() - 1);
}

3.1选择排序（Selection sort）

算法思想

是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

c++语言实现

void selectSort(MyArray &arr)
{
    for (int i = 0; i < arr.len(); i++)
    {
        int maxLoc = i;
        for (int j = i; j < arr.len(); j++)
        {
            maxLoc = (arr[j] > arr[maxLoc]) ? j: maxLoc;
        }
        arr.swap(i, maxLoc);
    }
}

算法分析

1.不稳定

2.复杂度

择排序的交换操作介于

和

次之间。选择排序的比较操作为

次之间。选择排序的赋值操作介于

和

次之间。

比较次数

，比较次数与关键字的初始状态无关，总的比较次数

。交换次数

，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换

次。交换次数比冒泡排序较少，由于交换所需CPU时间比比较所需的CPU时间多，

值较小时，选择排序比冒泡排序快。

原地操作几乎是选择排序的唯一优点，当方度（space complexity）要求较高时，可以考虑选择排序；实际适用的场合非常罕见。

堆排序（Heapsort）

详细的堆排序内容，请移步http://www.cnblogs.com/yatesxu/p/5404929.html

算法思想

是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

实质上是一个淘汰赛

算法实现

1.堆节点的访问

通常堆是通过一维数组来实现的。在数组起始位置为0的情形中：

• 父节点i的左子节点在位置(2*i+1);
• 父节点i的右子节点在位置(2*i+2);
• 子节点i的父节点在位置floor((i-1)/2);

2.堆的操作

在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义以下几种操作：

• 最大堆调整（Max_Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
• 创建最大堆（Build_Max_Heap）：将堆所有数据重新排序
• 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

算法分析

1.不稳定

2.复杂度

堆排序的平均时间复杂度为

，空间复杂度为

。

堆排序实例

归并排序 （Merge sort）

算法思想

归并操作（merge），也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

算法实现

1.迭代法

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

2.递归法

原理如下（假设序列共有n个元素）：

1. 将序列每相邻两个数字进行归并操作，形成

个序列，排序后每个序列包含两个元素

1. 将上述序列再次归并，形成

个序列，每个序列包含四个元素

1. 重复步骤2，直到所有元素排序完毕

算法分析

1.稳定

2.复杂度

比较操作的次数介于

和

。 赋值操作的次数是

。归并算法的空间复杂度为：Θ(n)

MyArray类

#include <iostream>
using namespace std;

class MyArray
{
    friend istream &operator>>(istream &is, MyArray &arr);
    friend  ostream &operator<<(ostream &os, const MyArray &arr);    
public:
    MyArray(int len = 32) :length(len)
    {
        ptrArr = new int[length];
        for (int i = 0; i < length; i++)
            ptrArr[i] = 0;
    };
    int len() const{ return length; }
    int& get(int i) const{ return ptrArr[i]; }
    void set(int loc, int num){ ptrArr[loc] = num; }
    void swap(int loc1, int loc2){ int tmp = ptrArr[loc1]; ptrArr[loc1] = ptrArr[loc2]; ptrArr[loc2] = tmp;}
    int& operator[](int i)const{ return get(i); }
private:
    int *ptrArr;
    int length;
};
#include"MyArray.h"
istream& operator>>(istream &is, MyArray &arr)
{
    for (int i = 0; i < arr.length; i++)
        is >> arr.ptrArr[i];
    return is;
}
ostream &operator<<(ostream &os, const MyArray &arr)
{
    for (int i = 0; i < arr.length; i++)
        cout << arr.ptrArr[i] << " ";
    return os;
}