基础堆排序及其优化

最新推荐文章于 2023-03-26 23:32:08 发布

liqian_blog

最新推荐文章于 2023-03-26 23:32:08 发布

阅读量1k

点赞数 1

分类专栏： C++，数据结构文章标签： C++ 堆排序建堆方式优化

本文链接：https://blog.csdn.net/liqian_blog/article/details/77965662

版权

C++，数据结构专栏收录该内容

15 篇文章 0 订阅

订阅专栏

我们将上一节中实现的堆放在Heap.h文件中，之前将的归并排序、快速排序分别放在merge.h和quick.h中，这一节实现堆排序，并将堆排序和归并排序、快速排序进行时间性能上的比较（堆排序也是时间复杂度为O(nlogn)的算法），整个C++代码如下：

Heap.h文件：

#include <iostream>
#include <cassert>
#include <algorithm>
#include <cstdlib>
#include <ctime>

using namespace std;

template<typename Item>
class MaxHeap
{
private:
    Item *data;
    int count;
    int capacity;
    void shiftUp(int k)
    {
        //凡是涉及到数组下标的，都要限定它不出界
        /*while(k > 1 && data[k] > data[k / 2])
        {
            swap(data[k], data[k / 2]);
            k /= 2;
        }*/

        //优化：用赋值取代交换
        Item item = data[k];
        while( k>1 && data[k/2] < item )
        {
            data[k] = data[k/2];
            k /= 2;
        }
        data[k] = item;
    }
    void shiftDown(int k)
    {
        //当k有孩子的情况下开始shiftDown操作
        /*while( 2*k <= count )
        {
            int j = 2*k;  //j就是要和data[k]交换的元素的位置下标
            //判断是否有右孩子
            if( j+1 <= count && data[j+1] > data[j] )
            {
                j = j + 1;
            }
            if(data[k] >= data[j])
            {
                break;
            }
            swap(data[k], data[j]);
            k = j;
        }*/

        //优化：用赋值取代交换
        Item item = data[k];
        while( 2*k <= count )
        {
            int j = 2*k;
            if(j + 1 <= count && data[j + 1] > data[j])
            {
                j = j + 1;
            }
            if(data[j] <= item)
            {
                break;
            }
            data[k] = data[j];
            k = j;
        }
        data[k] = item;
    }

public:
    MaxHeap(int capacity)
    {
        data = new Item[capacity + 1];  //从1号单元开始存放
        count = 0;
        this->capacity = capacity;
    }
    ~MaxHeap()
    {
        delete[] data;
    }
    //返回堆现在的大小
    int size() const
    {
        return count;
    }
    //判断堆是否为空堆
    bool isEmpty() const
    {
        return count == 0;
    }
    //向堆中插入一个元素
    void insert(Item item)
    {
        //判断count+1是否出界
        assert(count + 1 <= capacity);

        data[count + 1] = item;
        count++;
        //从count位置处开始向上调整堆
        shiftUp(count);  //这个函数不需要被用户调用，所以设为私有
    }
    //取出堆中的一个元素（只能取出根结点）
    Item extractMax()
    {
        //首先判断堆是否为空
        assert(count > 0);

        Item ret = data[1];
        data[1] = data[count];
        count--;
        shiftDown(1);
        return ret;
    }
    //打印堆中内容
    void printData() const
    {
        for(int i = 1; i <= count; i++)
        {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

merge.h文件

template<typename T>
void insertionSort(T arr[], int l, int r)  //将arr[l...r]区间内的元素进行插入排序
{
    for(int i = l + 1; i <= r; i++)
    {
        T e = arr[i];
        int j;
        for(j = i; j > l && arr[j - 1] > e; j--)
        {
            arr[j] = arr[j - 1];
        }
        arr[j] = e;
    }
}

//自顶向下的归并排序算法
template<typename T>
void __merge(T arr[], int l, int mid, int r)  //[l...r]（前闭后闭）
{
    T aux[r - l + 1];
    for(int i = l; i <= r; i++)  //i是aux的下标
    {
        aux[i - l] = arr[i];
    }
    //i、j是arr中的下标,k是arr中的下标
    //i-l、j-l是aux中的下标
    int i = l, j = mid + 1, k = l;
    while(i <= mid && j <= r)
    {
        if(aux[i - l] < aux[j - l])
        {
            arr[k++] = aux[i - l];
            i++;
        }
        else
        {
            arr[k++] = aux[j - l];
            j++;
        }
    }
    //出界条件
    while(i <= mid)
    {
        arr[k++] = aux[i - l];
        i++;
    }
    while(j <= r)
    {
        arr[k++] = aux[j - l];
        j++;
    }
}
template<typename T>
void __mergeSort(T arr[], int l, int r)  //一定要注意我设定的是左闭右闭[l...r]（r是最后一个元素）
{
    if(r - l <= 15)  //即所剩元素数量为16时
    {
        insertionSort(arr, l, r);
        return;  //返回上一层
    }
    else
    {
        int mid = (l + r) / 2;
        //对左半部分arr[l...mid]进行归并排序
        __mergeSort(arr, l, mid);
        //再对右半部分arr[mid + 1...r]进行归并排序
        __mergeSort(arr, mid + 1, r);
        //然后将排好序的左右两部分归并到一起
        if(arr[mid] > arr[mid + 1])  //优化
        {
            __merge(arr, l, mid, r);
        }
    }
}

template<typename T>
void mergeSort(T arr[], int n)
{
    //传递一个数组，调用归并排序算法归并arr[0...n-1]
    __mergeSort(arr, 0, n - 1);
}

quick.h文件

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "merge.h"

using namespace std;

//3路快速排序
template<typename T>
void __quickSort3Ways(T arr[], int l, int r)
{
    if(r - l <= 15)  //序列中仅有16个元素时
    {
        insertionSort(arr, l, r);
        return;
    }
    else
    {
        //因为需要返回lt和gt两个下标，所以这里不适用函数patition来进行划分
        //patition操作
        swap(arr[l], arr[rand() % (r - l + 1) + l]);
        T v = arr[l];
        int lt = l;  //保证<v的部分arr[l+1...lt]初始为空
        int gt = r + 1;  //保证>v的部分arr[gt...r]初始为空
        int i = l + 1; //保证==v的部分arr[lt+1...i)初始为空
        while(i < gt)
        {
            if(arr[i] < v)
            {
                swap(arr[lt + 1], arr[i]);
                i++;
                lt++;
            }
            else if(arr[i] == v)
            {
                i++;
            }
            else
            {
                swap(arr[i], arr[gt - 1]);
                gt--;
            }
        }
        //此时i == gt
        swap(arr[l], arr[lt]);

        //对arr[l...lt-1]进行递归
        __quickSort3Ways(arr, l, lt - 1);
        //对arr[gt...r]进行递归
        __quickSort3Ways(arr, gt, r);
    }
}

template<typename T>
void quickSort3Ways(T arr[], int n)
{
    srand(time(0));
    __quickSort3Ways(arr, 0, n - 1);
}

SortTestHelper.h文件（包含辅助函数）

#include <iostream>
#include <cstdlib>
#include <ctime>  //clock()、CLOCKS_PER_SEC
#include <cassert>  //包含函数assert()

using namespace std;

namespace SortTestHelper
{
    //辅助函数 - 随机产生一个数组
    int* generateRandomArray(int n, int RangeL, int RangeR)  //返回数组首地址
    {
        //判断RangeL是否<=RangeR
        assert(RangeL <= RangeR);  //参数为表达式，表达式为真时返回true，否则打印错误信息

        int *arr = new int[n];
        srand(time(0));
        for(int i = 0; i < n ; i++)
        {
            arr[i] = rand() % (RangeR - RangeL + 1) + RangeL;  //使得产生的随机数在RangeL和RangeR之间
        }
        return arr;
    }

    //辅助函数 - 产生一个近乎有序的随机数组
    int* generateNearlyOrderedArray(int n, int swapTime)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;  //先生成一个完全有序的数组
        }
        //然后交换几组元素，使之变成无序但近乎有序的数组
        srand(time(0));
        for(int j = 0; j < swapTime; j++)
        {
            //随机生成一个x位置和y位置
            int posx = rand() % n;
            int posy = rand() % n;
            //交换x和y处的元素
            swap(arr[posx], arr[posy]);
        }
        return arr;
    }

    //辅助数组 - 产生一个完全有序数组
    int* generateTotallyOrderedArray(int n)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;
        }
        return arr;
    }

    //辅助函数 - 打印数组
    template<typename T>
    void printArray(T arr[], int n)
    {
        for(int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    //辅助函数 - 判断数组是否有序（升序）
    template<typename T>
    bool isSorted(T arr[], int n)
    {
        for(int i = 0; i < n - 1; i++)
        {
            if(arr[i] > arr[i + 1])
            {
                return false;
            }
        }
        return true;
    }

    //辅助函数 - 测试算法的时间
    template<typename T>
    void testSort(string sortname, void(*sort)(T[], int), T arr[], int n)  //arr[]和n是函数指针需要的参数
    {
        clock_t starttime = clock();
        sort(arr, n);  //调用函数sort()
        clock_t endtime = clock();

        //判断排序是否成功
        assert(isSorted(arr, n));  //若是数组无序，则assert会自动调用abort()退出程序，不会执行下面的语句

        cout << sortname << " needs " << double(endtime - starttime) / CLOCKS_PER_SEC << "s." << endl;
    }

    //辅助函数 - 拷贝数组
    int* copyIntArray(int a[], int n)
    {
        int *arr = new int[n];
        //使用C++函数copy()
        copy(a, a + n, arr);
        return arr;
    }
}

main.cpp文件

#include <iostream>
#include "Heap.h"
#include "merge.h"
#include "quick.h"
#include "SortTestHelper.h"

using namespace std;

template<typename T>
void HeapSort(T arr[], int n)
{
    MaxHeap<T> maxheap = MaxHeap<T>(n);
    for(int i = 0; i < n; i++)
    {
        maxheap.insert(arr[i]);
    }
    //从小到大排序
    for(int i = n - 1; i >= 0; i--)
    {
        arr[i] = maxheap.extractMax();
    }
}

int main()
{
    int n = 500000;

    //测试 - 随机序列
    int *a = SortTestHelper::generateRandomArray(n, 0, n);
    int *a2 = SortTestHelper::copyIntArray(a, n);
    int *a3 = SortTestHelper::copyIntArray(a, n);
    SortTestHelper::testSort("mergeSort", mergeSort, a, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, a2, n);
    SortTestHelper::testSort("HeapSort", HeapSort, a3, n);
    delete[] a;
    delete[] a2;
    delete[] a3;

    //测试 - 近乎有序序列
    int swaptime = 100;
    int *b = SortTestHelper::generateNearlyOrderedArray(n, swaptime);
    int *b2 = SortTestHelper::copyIntArray(b, n);
    int *b3 = SortTestHelper::copyIntArray(b, n);
    SortTestHelper::testSort("mergeSort", mergeSort, b, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, b2, n);
    SortTestHelper::testSort("HeapSort", HeapSort, b3, n);
    delete[] b;
    delete[] b2;
    delete[] b3;

    //测试 - 重复键值序列
    int *c = SortTestHelper::generateRandomArray(n, 0, 10);
    int *c2 = SortTestHelper::copyIntArray(c, n);
    int *c3 = SortTestHelper::copyIntArray(c, n);
    SortTestHelper::testSort("mergeSort", mergeSort, c, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, c2, n);
    SortTestHelper::testSort("HeapSort", HeapSort, c3, n);
    delete[] c;
    delete[] c2;
    delete[] c3;
    return 0;
}

测试结果如下：

可以看出，三种排序算法的时间性能都很理想（三者都是时间复杂度为O(nlogn)的高级排序算法）。

不过对于堆排序，还可以对其进行优化，使其时间性能有所改善。

在上述将数组元素构建成堆的过程中，是将数组元素一个一个的插入到堆中，然后不断的shiftUp使之成为一个新的堆：

    MaxHeap<T> maxheap = MaxHeap<T>(n);
    for(int i = 0; i < n; i++)
    {
        maxheap.insert(arr[i]);
    }

实际上还有一种将数组元素构建成堆的方法，产生一个数组以后，可以将其写成完全二叉树的样子：

而这棵完全二叉树的所有叶子结点都可以看成是一个个最大堆。然后从第一个非叶子结点 count / 2 （这里就是索引5的位置）开始，执行shiftDown的操作（此处data[5] < data[10]，所以交换两者，是这两者构成的子树形成一个堆），然后对索引为4的元素进行shiftDown的操作，依次类推，直到对根结点作shiftDown的操作完毕后，整棵完全二叉树就形成一个堆。

此时，堆的声明中需要重新定义一个构造函数，参数为数组arr[]和数组大小n，然后将该数组赋值给data[]，然后在该构造函数内将data[]调整为最大堆，代码如下：

Heap.h文件中重新定义一个构造函数MaxHeap(Item arr[], int n)：

    MaxHeap(Item arr[], int n)
    {
        count = n;
        capacity = n;
        data = new Item[n + 1];
        for(int i = 1; i <= n; i++)
        {
            data[i] = arr[i - 1];
        }
        
        //将传入的数组整合成堆的样子
        for(int i = count / 2; i >= 1; i--)
        {
            shiftDown(i);
        }
    }

此时在main.cpp中重新定义一个HeapSort2算法，而将之前的HeapSort算法改为HeapSort1，然后测试两者算法的时间性能，完整的main.cpp文件如下：

#include <iostream>
#include "Heap.h"
#include "merge.h"
#include "quick.h"
#include "SortTestHelper.h"

using namespace std;

template<typename T>
void HeapSort1(T arr[], int n)
{
    MaxHeap<T> maxheap = MaxHeap<T>(n);
    for(int i = 0; i < n; i++)
    {
        maxheap.insert(arr[i]);
    }

    //从小到大排序
    for(int i = n - 1; i >= 0; i--)
    {
        arr[i] = maxheap.extractMax();
    }
}

template<typename T>
void HeapSort2(T arr[], int n)
{
    MaxHeap<T> maxheap = MaxHeap<T>(arr, n);

    //从小到大排序
    for(int i = n - 1; i >= 0; i--)
    {
        arr[i] = maxheap.extractMax();
    }
}

int main()
{
    int n = 500000;

    //测试 - 随机序列
    int *a = SortTestHelper::generateRandomArray(n, 0, n);
    int *a2 = SortTestHelper::copyIntArray(a, n);
    int *a3 = SortTestHelper::copyIntArray(a, n);
    int *a4 = SortTestHelper::copyIntArray(a, n);
    SortTestHelper::testSort("mergeSort", mergeSort, a, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, a2, n);
    SortTestHelper::testSort("HeapSort1", HeapSort1, a3, n);
    SortTestHelper::testSort("HeapSort2", HeapSort2, a4, n);
    cout << endl;
    delete[] a;
    delete[] a2;
    delete[] a3;
    delete[] a4;

    //测试 - 近乎有序序列
    int swaptime = 100;
    int *b = SortTestHelper::generateNearlyOrderedArray(n, swaptime);
    int *b2 = SortTestHelper::copyIntArray(b, n);
    int *b3 = SortTestHelper::copyIntArray(b, n);
    int *b4 = SortTestHelper::copyIntArray(b, n);
    SortTestHelper::testSort("mergeSort", mergeSort, b, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, b2, n);
    SortTestHelper::testSort("HeapSort1", HeapSort1, b3, n);
    SortTestHelper::testSort("HeapSort2", HeapSort2, b4, n);
    cout << endl;
    delete[] b;
    delete[] b2;
    delete[] b3;
    delete[] b4;

    //测试 - 重复键值序列
    int *c = SortTestHelper::generateRandomArray(n, 0, 10);
    int *c2 = SortTestHelper::copyIntArray(c, n);
    int *c3 = SortTestHelper::copyIntArray(c, n);
    int *c4 = SortTestHelper::copyIntArray(c, n);
    SortTestHelper::testSort("mergeSort", mergeSort, c, n);
    SortTestHelper::testSort("quickSort3Ways", quickSort3Ways, c2, n);
    SortTestHelper::testSort("HeapSort1", HeapSort1, c3, n);
    SortTestHelper::testSort("HeapSort2", HeapSort2, c4, n);
    cout << endl;
    delete[] c;
    delete[] c2;
    delete[] c3;
    delete[] c4;
    return 0;
}

测试结果如下：

可见不同的建堆方式带来的时间性能是不同的，HeapSort2中的建堆方式（称为Heapify）总是比HeapSort1中的快，但是无论是HeapSort1还是HeapSort2，它们的时间性能在不同的情况下都是不如归并排序和快速排序的，正是因为如此，所以在系统级别实现的排序中，是很少使用堆排序的。堆这种数据结构更多地使用于对于动态数据的维护上面。

那么为什么上述两种建堆的方式的时间性能不同呢？这里给出一个结论（数学证明略）：将n个元素逐一地插入到一个空堆中，算法的时间复杂度为O(nlogn)；而将一个数组heapify的过程，其时间复杂度为O(n)。所以HeapSort2的时间性能比HeapSort1要好。简单地讲，在Heapify的过程中直接对所有的叶子结点不作任何操作，肯定是比一个一个插入空堆要快的。

在这一节中，实现的堆排序算法，其空间复杂度为O(n)，而实际上我们可以不适用任何辅助空间，直接原地对数组进行堆排序，这些内容将在下一节对堆排序的优化中讲到。

liqian_blog

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
基础堆排序及其优化

我们将上一节中实现的堆放在Heap.h文件中，之前将的归并排序、快速排序分别放在merge.h和quick.h中，这一节实现堆排序，并将堆排序和归并排序、快速排序进行时间性能上的比较（堆排序也是时间复杂度为O(nlogn)的算法），整个C++代码如下： Heap.h文件：#include #include #include #include #include using na
复制链接

扫一扫