《算法导论》— Chapter 6 堆排序

序

本文主要介绍堆排序算法（HeapSort），堆排序像合并排序而不像插入排序，堆排序的运行时间为O(nlgn)；像插入排序而不像合并排序，它是一种原地(in place)排序算法。在任何时候，数组中只有常数个元素存储在输入数组以外，这样，堆排序就把插入排序和合并排序的优点结合起来。

堆排序还引入了另外一种算法设计技术，利用某种数据结构(在此算法中为“堆”)来管理算法执行中的信息。堆数据结构不只在堆排序算法中有用，还可以构成一个有效的优先队列。堆数据结构是一种数组对象，它可以被视为一颗完全二叉树，树种每个结点与数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外(最后一层从一个结点的左子树开始填)。

堆数据结构在最大（最小）优先级队列中得到有效的应用，本文以大顶堆为例，详细给出堆排序算法的实现以及最大级优先队列的算法实现。

git代码

GitHub chapter 6 程序代码下载

堆数据结构

堆数据结构是一种数组抽象，它可以被看做一颗完全二叉树，树中每个结点与数组中存放该结点值的那个元素对应。除了堆顶根节点之外，所有树结点都有父节点，同理，除了叶子结点外，所有树结点都至少有一个儿子结点。

//求左儿子结点
int Left(int i)
{
    return 2 * i;
}

//求右儿子结点
int Right(int i)
{
    return 2 * i + 1;
}

//求父节点
int Parent(int i)
{
    return i / 2;
}

在堆排序算法中，有以下几个关键步骤：

MaxHeapify过程，其运行时间为O(logn)，是保持最大堆性质的关键；

BuildMaxHeap过程，建立大顶堆，在无序的原始数组中构造出一颗大顶堆；

HeapSort过程，对大顶堆从最后一个叶子结点开始处理排序，得到一组升序排列的序列。

堆排序算法实现

(1) MaxHeap.h

#ifndef MAX_HEAP_H
#define MAX_HEAP_H

/*
 * 大顶堆 MaxHeap 数据结构
 */

#include <iostream>

using namespace std;
class MaxHeap
{
public:
    MaxHeap(int *data, int size);
    ~MaxHeap();
    void maxHeapSort();
    void displayList(int size)
    {
        for (int i = 0; i < size; i++)
            cout << m_dataList[i] << "\t";
        cout << endl;
    }
private:
    int *m_dataList;
    int m_heapSize;

    void buildMaxHeap(int *data);
    void maxHeapify(int *data, int i);

    int Left(int i)
    {
        return 2 * i;
    }

    int Right(int i)
    {
        return 2 * i + 1;
    }

    void swap(int &a, int &b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
};
#endif

(2)MaxHeap.cpp

#include "MaxHeap.h"
#include <iostream>

using namespace std;

MaxHeap::MaxHeap(int *data, int size) :m_dataList(data), m_heapSize(size)
{}

MaxHeap::~MaxHeap()
{
    delete m_dataList;
}

void MaxHeap::buildMaxHeap(int *data)
{
    for (int i = m_heapSize / 2; i >= 1; i--)
    {
        maxHeapify(data, i);
    }
}

void MaxHeap::maxHeapify(int *data, int i)
{
    int largest;
    int left = Left(i);
    int right = Right(i);

    if (left <= m_heapSize && data[left-1] > data[i-1])
        largest = left;
    else
        largest = i;

    if (right <= m_heapSize && data[right-1] > data[largest-1])
        largest = right;

    if (largest != i)
    {
        swap(data[i - 1], data[largest - 1]);
        maxHeapify(data, largest);
    }
}

void MaxHeap::maxHeapSort()
{
    buildMaxHeap(m_dataList);
    int length = m_heapSize;
    for (int i = length; i >= 1; i--)
    {
        swap(m_dataList[i - 1], m_dataList[0]);
        m_heapSize--;
        maxHeapify(m_dataList, 1);
    }

}

(3)main.cpp

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

using namespace std;

const int N = 10;
int main()
{
    //声明一个待排序数组
    int array[N];
    //设置随机化种子，避免每次产生相同的随机数
    srand(time(0));
    for (int i = 0; i<N; i++)
    {
        array[i] = rand() % 101;//数组赋值使用随机函数产生1-100之间的随机数
    }

    //调用堆排序函数对该数组进行排序
    MaxHeap *maxHeap = new MaxHeap(array, N);
    cout << "排序前：" << endl;
    maxHeap->displayList(N);

    maxHeap->maxHeapSort();
    cout << endl << "排序后：" << endl;
    maxHeap->displayList(N);
    system("pause");
    return 0;
}

测试结果：

最大优先级队列

优先级队列是一种用来维护一组元素构成的集合元素的数据结构，这一组元素中的每一个都有关键字key，分为最大优先级队列和最小优先级队列两种。

本章集中讨论了基于最大堆实现的最大优先级队列。

一个最大优先级队列有以下关键操作：

Insert(x) : 将关键字x插入集合，并保持集合的性质；

MaxiMum()：返回集合中最大关键字的元素，对于最大优先级队列，队头元素即是最大关键字元素；

ExtractMax() ： 去掉并返回队列集合中最大关键字的元素；

IncreaseKey(x , k) : 将元素位置x处的关键字值增加到k ， k 本值不可小于x位置元素的初始值；

算法实现：

（1） MaxPriQueue.h

#ifndef _MAXPRIQUEUE_H_
#define _MAXPRIQUEUE_H_

/*
* 最大堆实现的最大优先级队列数据结构
*/
#include <iostream>
using namespace std;

class MaxPriQueue{

public:

    MaxPriQueue(int *data, int size);
    ~MaxPriQueue();

    //将元素x插入该优先级队列
    void insert(int x);

    //去掉并返回队列中具有最大关键字的元素
    int extractMax();

    //将元素x的关键字的值增加到k
    void increaseKey(int x, int k);

    void maxHeapify(int *data, int i);

    int MaxiMum()
    {
        return m_dataList[0];
    }

    void displayList()
    {
        for (int i = 0; i < m_queueSize; i++)
            cout << m_dataList[i] << "\t";
        cout << endl;
    }

private:
    int *m_dataList;
    int m_queueSize; //优先级当前长度

    //求左儿子结点
    int Left(int i)
    {
        return 2 * i;
    }

    //求右儿子结点
    int Right(int i)
    {
        return 2 * i + 1;
    }

    //求父节点
    int Parent(int i)
    {
        return i / 2;
    }

    void swap(int &a, int &b)
    {
        int temp = a;
        a = b;
        b = temp;
    }

    void buildMaxHeap(int *data);
};

#endif

(2) MaxPriQueue.cpp

#include "MaxPriQueue.h"
#include <iostream>

using namespace std;

//构造函数
MaxPriQueue::MaxPriQueue(int *data, int size) :m_dataList(data), m_queueSize(size)
{
    //构建大顶堆
    buildMaxHeap(m_dataList);
}

MaxPriQueue::~MaxPriQueue()
{
    delete m_dataList;
}

void MaxPriQueue::buildMaxHeap(int *data)
{
    //从最后一个根元素自底向上调整
    for (int i = m_queueSize / 2; i >= 1; i--)
        maxHeapify(data, i);
}

int MaxPriQueue::extractMax()
{
    if (m_queueSize < 1)
        return -1;

    int max = m_dataList[0];

    m_dataList[0] = m_dataList[m_queueSize - 1];
    m_queueSize--;

    maxHeapify(m_dataList, 1);

    return max;

}

void MaxPriQueue::increaseKey(int x, int k)
{
    if (k < m_dataList[x-1])
        return;

    m_dataList[x-1] = k;

    //自底向上调整大顶堆
    while (x > 1 && m_dataList[Parent(x)-1] < m_dataList[x-1])
    {
        swap(m_dataList[Parent(x)-1], m_dataList[x-1]);
        x = Parent(x);
    }
}

void MaxPriQueue::insert(int x)
{
    m_queueSize++;
    m_dataList[m_queueSize - 1] = x-1;
    increaseKey(m_queueSize, x);
}

void MaxPriQueue::maxHeapify(int *data, int i)
{
    int largest;
    int left = Left(i);
    int right = Right(i);

    if (left <= m_queueSize && data[left - 1] > data[i - 1])
        largest = left;
    else
        largest = i;

    if (right <= m_queueSize && data[right - 1] > data[largest - 1])
        largest = right;

    if (largest != i)
    {
        swap(data[i - 1], data[largest - 1]);
        maxHeapify(data, largest);
    }
}

(3) main.cpp

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

using namespace std;

const int N = 10;
int main()
{
    //声明一个待排序数组
    int array[N];
    //设置随机化种子，避免每次产生相同的随机数
    srand(time(0));
    for (int i = 0; i<N; i++)
    {
        array[i] = rand() % 101;//数组赋值使用随机函数产生1-100之间的随机数
    }

    //调用堆排序函数对该数组进行排序
    MaxPriQueue *maxPriQueue = new MaxPriQueue(array, N);

    cout << "大顶堆：" << endl;
    maxPriQueue->displayList();

    cout << "堆顶元素" << maxPriQueue->MaxiMum() << endl;

    cout << "删除最大元素" << maxPriQueue->extractMax() << endl;

    cout << "新的大顶堆：" << endl;
    maxPriQueue->displayList();

    cout << "将队头元素增加至100." << endl;
    maxPriQueue->increaseKey(1, 100);
    cout << "新的大顶堆：" << endl;
    maxPriQueue->displayList();

    system("pause");
    return 0;
}

测试结果：