图解十大排序算法

冒泡排序

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

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

时间复杂度

平均时间复杂度	稳定性
O(n^2)	稳定

原理

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

关键代码

// 冒泡排序循环
for (int i = data_num_; i > 1 && !paused_ && !stop_; i--)
{
    for (int j = 0; j < i-1 && !paused_ && !stop_; j++)
    {
        emit sig_selectData(j,j+1 ,type_);
        msleep(10); // 停留1ms
        if (bar_sets_[j]->at(0) > bar_sets_[j+1]->at(0))
        {
            int temp1 = bar_sets_[j]->at(0);
            int temp2 = bar_sets_[j+1]->at(0);
            bar_sets_[j]->replace(0,temp2);
            bar_sets_[j+1]->replace(0, temp1);
            swap_num_ += 3;
        }
        cmp_num_ += 1; // 比较次数+1
        msleep(100);
    }
    if (i == 2)
    {
        end_ = true;
        emit sig_bubbleFinished(cmp_num_, swap_num_ ,type_);
    }
}

结果演示

选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

时间复杂度

平均时间复杂度	稳定性
O(n^2)	不稳定

原理

选择排序算法的原理如下：

1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3.重复第二步，直到所有元素均排序完毕。

关键代码

for(int i = 0; i < data_num_ && !paused_ && !stop_ ; i++)
{
    int tI = i;
    for(int j = i; j < data_num_; j++)
    {
        if(bar_sets_[tI]->at(0) > bar_sets_[j]->at(0))
        {
            tI = j;
        }
        emit sig_selectData(tI, i, type_);
        msleep(10);
    }
    int temp1 = bar_sets_[i]->at(0);
    int temp2 = bar_sets_[tI]->at(0);
    bar_sets_[i]->replace(0,temp2);
    bar_sets_[tI]->replace(0, temp1);

    swap_num_ += 3;
    cmp_num_ += 1;
    msleep(100);
}
emit sig_bubbleFinished(cmp_num_, swap_num_,type_);
end_ = true;

结果演示

插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

时间复杂度

平均时间复杂度	稳定性
O(n^2)	稳定

原理

插入排序算法的原理如下：

1.将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

2.从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

关键代码

for (int i = 1; i < data_num_; i++)
{
    int temp = bar_sets_[i]->at(0);
    int j = i;
    while (j >= 1 && temp < bar_sets_[j - 1]->at(0)) {
        emit sig_selectData(i,j, type_);
        msleep(20);
        bar_sets_[j]->replace(0,bar_sets_[j - 1]->at(0));
        j--;
        emit sig_selectData(i,j, type_);
        msleep(20);
    }
    bar_sets_[j]->replace(0,temp);
    emit sig_selectData(i,j, 2);
    msleep(20);
    emit sig_bubbleFinished(cmp_num_, swap_num_, type_);
    end_ = true;
}

结果演示

希尔排序

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

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

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

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

时间复杂度

平均时间复杂度	稳定性
O(nlogn)	不稳定

原理

希尔排序算法的原理如下：

1.选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

2.按增量序列个数 k，对序列进行 k 趟排序；

3.每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

关键代码

for(int mid = data_num_ / 2; mid >= 1; mid = mid/2)
{
    for(int i = 0; i < mid; i++)
    {
        for(int j = i + mid ; j < data_num_; j=j+mid)
        {
            int temp = bar_sets_[j]->at(0);
            int k = j - mid;
            while(k >= 0 && bar_sets_[k]->at(0) > temp)
            {
                emit sig_selectData(k + mid, k,type_);
                msleep(100);
                bar_sets_[k + mid]->replace(0,bar_sets_[k]->at(0));
                k = k - mid;
            }
            bar_sets_[k + mid]->replace(0,temp);
        }
    }
}
emit sig_bubbleFinished(cmp_num_, swap_num_,type_);
end_ = true;

结果演示

归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

• 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
• 自下而上的迭代；

时间复杂度

平均时间复杂度	稳定性
O(nlogn)	稳定

原理

归并排序算法的原理如下：

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

关键代码

void MergeThread::merge(int left, int mid, int right)
{
    mux.lock();
    vector<int> help;
    help.resize(right - left + 1,0);
    int i = left;
    int j = mid + 1;
    int index = 0;
    while (i <= mid && j <= right)
    {
        if (bar_sets_[i]->at(0) <= bar_sets_[j]->at(0))
        {
            emit sig_selectData(i,index,type_);
            msleep(20);
            help[index] = bar_sets_[i]->at(0);
            i++;
            index++;
        }
        else
        {
            emit sig_selectData(j,index,type_);
            msleep(20);
            help[index] = bar_sets_[j]->at(0);
            j++;
            index++;
        }
    }
    while (i <= mid)
    {
        emit sig_selectData(i,index,type_);
        msleep(20);
        help[index] = bar_sets_[i]->at(0);
        i++;
        index++;
    }
    while (j <= right)
    {
        emit sig_selectData(j,index,type_);
        msleep(20);
        help[index] = bar_sets_[j]->at(0);
        j++;
        index++;
    }

    index = left;
    for (int i = 0; i <= right - left; i++)
    {
        emit sig_selectData(i,index,type_);
        msleep(20);
        bar_sets_[index]->replace(0, help[i]);
        index++;
    }
    mux.unlock();
}

void MergeThread::mergeSort(int left, int right)
{
    if (left >= right)
    {
        return;
    }
    int mid = (left + right) / 2;
    mergeSort(left, mid);
    mergeSort(mid + 1, right);
    merge(left, mid, right);
}

结果演示

快速排序

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

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

时间复杂度

平均时间复杂度	稳定性
O(nlogn)	不稳定

原理

快速排序算法的原理如下：

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

关键代码

void QuickThread::quickSort(int start, int last)
{
    int i = start;
    int j = last;
    if (i < j)
    {
        int temp = bar_sets_[i]->at(0);
        emit sig_selectData(i,j,type_);
        msleep(100); // 停留1ms
        while (i < j)
        {
            while (i < j &&  bar_sets_[j]->at(0) >= temp )
                j--;
            if (i < j)
            {
                bar_sets_[i]->replace(0,bar_sets_[j]->at(0));
                i++;
            }
            emit sig_selectData(i,j,type_);
            msleep(100); // 停留1ms
            while (i < j && temp > bar_sets_[i]->at(0))
                i++;
            if (i < j)
            {
                bar_sets_[j]->replace(0,bar_sets_[i]->at(0));
                j--;
            }
            emit sig_selectData(i,j,type_);
            msleep(100); // 停留1ms
        }
        bar_sets_[i]->replace(0, temp);
        quickSort(start, i - 1);
        quickSort(i + 1, last);
    }
}

结果演示

堆排序

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

1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

时间复杂度

平均时间复杂度	稳定性
O(nlogn)	不稳定

原理

堆排序算法的原理如下：

1. 创建一个堆 H[0……n-1]；
2. 把堆首（最大值）和堆尾互换；
3. 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
4. 重复步骤 2，直到堆的尺寸为 1。

关键代码

//堆排序的核心是建堆
void HeapThread::buildHeap(int root, int length)
{
    int lChild = root*2+1;//根节点的左子结点下标
    if (lChild < length)//左子结点下标不能超出数组的长度
    {
        int flag = lChild;//flag保存左右节点中最大值的下标
        int rChild = lChild+1;//根节点的右子结点下标
        if (rChild < length)//右子结点下标不能超出数组的长度(如果有的话)
        {
            if (bar_sets_[rChild]->at(0) > bar_sets_[flag]->at(0))//找出左右子结点中的最大值
            {
                flag = rChild;
            }
        }
        if (bar_sets_[root]->at(0) < bar_sets_[flag]->at(0))
        {

            emit sig_selectData(root, flag, 7);
            msleep(20);
            //交换父结点和比父结点大的最大子节点
            int temp1 = bar_sets_[root]->at(0);
            int temp2 = bar_sets_[flag]->at(0);
            bar_sets_[root]->replace(0, temp2);
            bar_sets_[flag]->replace(0, temp1);
            //从此次最大子节点的那个位置开始递归建堆
            buildHeap(flag, length);
        }
    }
}

void HeapThread::run()
{
    stop_ = false;
    end_ = false;
    while (!stop_ && !end_)
    {
        for (int i = data_num_/2; i >= 0; --i) //从最后一个非叶子节点的父结点开始建堆
        {
            buildHeap(i, data_num_);
        }

        for (int j = data_num_-1; j > 0; --j) //j表示数组此时的长度，因为len长度已经建过了，从len-1开始
        {
            emit sig_selectData(0, j, type_);
            msleep(20);
            int temp1 = bar_sets_[0]->at(0);
            int temp2 = bar_sets_[j]->at(0);
            bar_sets_[0]->replace(0, temp2);
            bar_sets_[j]->replace(0, temp1);
            buildHeap(0,j);//去除最后位置的元素重新建堆，此处j表示数组的长度，最后一个位置下标变为len-2
        }
        emit sig_bubbleFinished(cmp_num_, swap_num_, type_);
        end_ = true;
    }
    quit();
}

结果演示

计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

1. 计数排序的特征

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。

时间复杂度

平均时间复杂度	稳定性
O(n+k)	稳定

原理

计数排序算法的原理如下：

1.找出待排序的数组中最大和最小的元素

2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项

3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）

4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

关键代码

int CountingThread::getMaxData()       //数组最大值
{
    int max = INT_MIN;
    for (int i = 0; i < data_num_; i++)
    {
        max = bar_sets_[i]->at(0) > max?bar_sets_[i]->at(0):max;
    }
    return max;
}

void CountingThread::run()
{
    stop_ = false;
    end_ = false;
    while (!stop_ && !end_)
    {
        int max = getMaxData();
        vector<int> bucket(max + 1, 0);
        int sortedIndex = 0;
        int bucketLen = max + 1;
        for (int i = 0; i < data_num_; i++)
        {
            emit sig_selectData(i, i ,type_);
            msleep(20);
            if (!bucket[bar_sets_[i]->at(0)])
            {
                bucket[bar_sets_[i]->at(0)] = 0;
            }
            bucket[bar_sets_[i]->at(0)]++;

        }

        for (int j = 0; j < bucketLen; j++)
        {
            while (bucket[j] > 0)
            {
                emit sig_selectData(sortedIndex, sortedIndex , type_);
                msleep(20);
                bar_sets_[sortedIndex]->replace(0, j);
                sortedIndex++;
                bucket[j]--;
            }
        }

        emit sig_bubbleFinished(cmp_num_, swap_num_,type_);
        end_ = true;
    }
    quit();
}

结果演示

桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

1. 在额外空间充足的情况下，尽量增大桶的数量
2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

时间复杂度

平均时间复杂度	稳定性
O(n + k)	稳定

原理

插入排序算法的原理如下：

1.确定桶的个数
2.将数据按照一个规则分类
3.遍历数组 arr，计算每个元素 arr[i] 放的桶
4.每个桶各自排序
5.遍历桶数组，把排序好的元素放进输出数组

关键代码

void BucketThread::bubbleSort(vector<int> &nums)
{
    int size = nums.size();
    if (size < 2) return;

    for (int i = 0; i < size; i++)
    {
        for (int j = 0;j < size -1;j++)
            if (nums[j] > nums[j + 1])
            {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
    }
    return;
}

void BucketThread::run()
{
    stop_ = false;
    end_ = false;
    while (!stop_ && !end_)
    {
        vector<vector<int>> bucket;
        bucket.resize(11);
        for (int i = 0; i < data_num_; i++)
        {
            //将数组元素装进各桶中
            emit sig_selectData(i, i, type_);
            msleep(20);
            bucket[bar_sets_[i]->at(0) / 10].push_back(bar_sets_[i]->at(0));
        }

        for (int i = 0;i < 11;i++)
        {
            //各桶内进行排序
            bubbleSort(bucket[i]);
        }

        int sign = 0;//各桶内元素赋值给原数组
        for (int i = 0;i < 11;i++)
        {
            for (int j = 0;j < bucket[i].size();j++)
            {
                emit sig_selectData(sign, sign, type_);
                msleep(20);
                bar_sets_[sign]->replace(0, bucket[i][j]);
                sign++;
            }
        }

        emit sig_bubbleFinished(cmp_num_, swap_num_, type_);
        end_ = true;
    }
    quit();
}

结果演示

基数排序

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法：

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

• 基数排序：根据键值的每位数字来分配桶；
• 计数排序：每个桶只存储单一键值；
• 桶排序：每个桶存储一定范围的数值

时间复杂度

平均时间复杂度	稳定性
O(n + k)	稳定

原理

插入排序算法的原理如下：

1.确定数组中的最大元素有几位（MAX）（确定执行的轮数）

2.创建0_{9个桶（桶的底层是队列），因为所有的数字元素都是由0}9的十个数字组成

3.依次判断每个元素的个位，十位至MAX位，存入对应的桶中，出队，存入原数组；直 至MAX轮结束输出数组。

4.具体实现步骤如下图

关键代码

int RadixThread::getCurrentPieceData(int num, int d)        //获取d位上的数
{
    while (d > 1)
    {
        d--;
        num /= 10;
    }
    return num % 10;
}
int RadixThread::getMaxPieces(int num)          //获取最大位数
{
    int d = 0;
    while (num)
    {
        d++;
        num /= 10;
    }
    return d;
}
int RadixThread::getMaxData()       //数组最大值
{
    int max = INT_MIN;
    for (int i = 0; i < data_num_; i++)
    {
        max = bar_sets_[i]->at(0) > max?bar_sets_[i]->at(0):max;
    }
    return max;
}

void RadixThread::run()
{
    stop_ = false;
    end_ = false;
    while (!stop_ && !end_)
    {
        int radix = 10;
        int* count = new int[radix];     //记录d位上的数进行出桶入桶
        vector<int> help;
        help.resize(data_num_,0);
        int max = getMaxData();
        int maxPiece = getMaxPieces(max);
        for (int d = 1; d <= maxPiece; d++)
        {
            memset(count, 0, radix * 4);      //初始化
            for (int i = 0; i < data_num_; i++)
            {
                int j = getCurrentPieceData(bar_sets_[i]->at(0), d);
                count[j]++;

                emit sig_selectData(i, j,type_);
                msleep(20);
            }
            for (int i = 1; i < radix; i++)        //记录>=d位的数量
            {
                count[i] = count[i] + count[i - 1];
                emit sig_selectData(i,i,type_);
                msleep(20);
            }
            for (int i = data_num_ - 1; i >= 0; i--)     //入桶
            {
                int j = getCurrentPieceData(bar_sets_[i]->at(0), d);
                help[count[j] - 1] = bar_sets_[i]->at(0);
                count[j]--;
                emit sig_selectData(i, j,type_);
                msleep(20);
            }
            for (int i = 0; i < data_num_; i++)      //出桶
            {
                bar_sets_[i]->replace(0,help[i]);
                emit sig_selectData(i, i,type_);
                msleep(20);
            }
        }

        emit sig_bubbleFinished(cmp_num_, swap_num_,type_);
        end_ = true;
    }
    quit();
}

结果演示

演示项目开源地址：

https://gitee.com/turbolove/sort.git

如果你喜欢的话，请一键三连哟。