【数据结构】排序（2）——直接选择排序、堆排序

文章目录

前言
一、直接选择排序
二、堆排序🌟🌟

前言

本节我们将详细讲解选择排序。

选择排序的基本思想💭：
每一次从待排序的数据元素中选出最小（或最大） 的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

一、直接选择排序

1.1、基本思想与分析

直接选择排序的基本步骤如下：

在元素集合 array[i] ~ array[n-1] 中选择关键码最大(或最小)的数据元素。
若它不是这组元素中的最后一个(或第一个)元素，则将它与这组元素中的最后一个（或第一个）元素交换。
在剩余的 array[i] ~ array[n-2]（或array[i+1] ~ array[n-1]）集合中，重复上述步骤，直到集合剩余 1 个元素。

以上步骤非常简单好理解，但是，这种方法时间复杂度绝对不太友好。

我们是否能够在此基础上做优化呢🧐？？

当然是可以的🤓！！在寻找最值的过程中，既然能够找到一个最大值（或最小值），那么找到当前数据范围内的最小值（或最大值）一定也不是什么难事。朝着这个方向修改，我们就起码可以减少一半的遍历次数。具体过程可以参考下图🎨：
图示有非常重要的细节处理！！

1.2、代码实现💻

cpp 复制代码

// 直接选择排序--升序
void SelectSort(std::vector<int> &v)
{
    int begin = 0, end = v.size() - 1;
    // 乱序数组的首元素begin, 尾元素end
    while (begin < end)
    {
        int Min_i = begin; // 小标 - 找最小值
        int Max_i = begin; // 小标 - 找最大值
        for (int i = begin; i <= end; i++)
        {
            if (v[Max_i] < v[i])
            {
                Max_i = i;
            }
            if (v[Min_i] > v[i])
            {
                Min_i = i;
            }
        }
        // if (Max_i == begin)
        // {
        //     Max_i = Min_i;
        // }
        // std::swap(v[begin], v[Min_i]);
        // std::swap(v[end], v[Max_i]);
        if (Min_i == end)
        {
            Min_i = Max_i;
        }
        std::swap(v[end], v[Max_i]);
        std::swap(v[begin], v[Min_i]);
        begin++;
        end--;
    }
}

1.3、时间复杂度分析

我们以排升序为例：

考虑最坏的情况，不难看出这是一个O(n^2)的时间复杂度。

即使是优化版本，直接交换排序的效率也非常低，因此实际中极少使用。

二、堆排序🌟🌟

2.1、基本思想与分析

根据选择排序的基本思想，我们应该能够很轻易地想到堆这个数据结构。

通过堆，能够极快地找到待排数组中的最大值（或最小值）。此过程时间复杂度为O(1)

不过，实际上的堆排序并没有使用堆这个数据结构，而是利用了堆的思想 ，这一点尤其要注意！！

具体的模拟过程请看下图🎨：

2.2、代码实现💻

cpp 复制代码

// 堆排序
void adjustDown(std::vector<int> &v, int parent, int n)
{
    int child = parent * 2 + 1;
    while (child < n)
    {
        //大堆 <
        //小堆 >
        if (child + 1 < n && v[child] < v[child + 1])
            child++;

        //大堆 <
        //小堆 >
        if (v[parent] < v[child])
        {
            std::swap(v[child], v[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}
void adjustUp(std::vector<int>& v, int child)
{
    int parent = (child - 1) / 2;
    while(child > 0)
    {
        // 大堆 <
        // 小堆 >
        if(v[parent] < v[child])
        {
            std::swap(v[parent], v[child]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
            break;
    }
}
void HeapSort(std::vector<int> &v)
{
    int n = v.size();
    // 既可以向上调整建堆，也可以向下调整建堆
    // 但是建议使用向下调整建堆
    for (int i = (n - 1) / 2; i >= 0; i--)
    {
        // 向下调整建立堆结构 O(n)
        adjustDown(v, i, n);
    }

    for (int i = n - 1; i > 0; i--)
    {
        std::swap(v[i], v[0]);
        // 这里必须使用向下调整算法
        adjustDown(v, 0, i);
    }
}

2.3、时间复杂度分析

通过代码部分我们可以看出，堆排序主要有两个循环构成，第一个循环用于建堆，第二个循环用于交换元素与调整堆结构，因此时间复杂度推导：

建堆：向下调整建堆，时间复杂度为O(n)
每次交换调整 ：总共n - 1个元素，每次调整时间复杂度都为O(logn)。因此，此步骤的时间复杂度为O(nlogn)

综上，堆排序的时间复杂度整体上为O(nlogn)。

完💯💯💯