【数据结构与算法】第6章优先队列（堆）

最新推荐文章于 2022-02-08 15:15:16 发布

huihuiwith

最新推荐文章于 2022-02-08 15:15:16 发布

阅读量394

点赞数

分类专栏：数据结构与算法--note

本文链接：https://blog.csdn.net/lc250123/article/details/82966784

版权

数据结构与算法--note 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

具有特殊优先级的队列叫做优先队列。像操作系统中，调度算法往往会使用优先队列结构。优先队列至少允许下列两种操作：insert，deleteMin（找出、返回和删除优先队列中的最小项）。

二叉堆

下面将讨论其结构性质和堆序性质。

（1）结构性质

二叉堆是一棵被完全填满的二叉树（即完全二叉树），可能的例外是在底层，底层元素从左到右填入。如下：

因为完全二叉树很有规律，所以可以用一个数组表示而不需要使用链。因为对于数组中任意位置 i 上的元素，其左儿子在位置 2i 上，右儿子在左儿子后的单元（2i + 1）中，它的父亲则在位置 $\left \lfloor i/2 \right \rfloor$ 上。

上图的数组存储如下（注意是从下标为 1 的位置存储第一个元素）：

如下是优先队列（堆）的整体接口：

template<typename Comparable>
class BinaryHeap
{
public:
    explicit BinaryHeap(int capacity = 100);
    explicit BinaryHeap(const vector<Comparable> & items);

    bool isEmpty() const;
    const Comparable & findMin() const;

    void insert(const Comparable & x);
    void deleteMin();
    void deleteMin(Comparable & minItem);
    void makeEmpty();

private:
    int currentSize;    //堆中元素的个数
    vector<Comparable> array;   //存放堆的数组

    void buildHeap();
    void percolateDown(int hole);
};

（2）堆序性质

使操作可以快速执行的性质即是堆序性质。由于要快速的找到最小元，因此最小元应该在根上。如果任意子树也是堆，那么任意结点就应该小于它的所有后裔。

插入操作：insert

插入操作使用一种叫做上滤的策略，新元素在堆中上滤直到找出正确的位置。如将一个元素 X 插入到堆中，我们在下一个空闲的位置创建一个空穴，因为否则该堆将不是完全树。如果 X 可以放在空穴中而并不破坏堆序，那么插入完成。否则把空穴的父结点上的元素移入空穴中，这样空穴就朝着根的方向上行一步。继续该过程直到 X 能被放入空穴中为止。所以最好的时间 O(1)，最坏为 O(logN)。业已证明，执行一次插入平均需要比较 2.607 次，元素平均上移 1.607 层。

    void insert(const Comparable & x)
    {
        if(currentSize == array.size()-1)
            array.resize(array.size()*2);
        
        //上滤
        int hole = ++currentSize;
        for( ; hole>1 && x<array[hole/2]; hole/=2)
            array[hole] = array[hole/2];
        
        array[hole] = x;
    }

如下是一个插入过程：

deleteMin操作

该操作使用一种叫做下滤的策略。当删除一个最小元时，要在根结点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素 X 必须移动到该堆的某个地方。如果 X 可以被放到空穴中，那么 deleteMin 完成。否则我们将空穴的两个儿子中的较小者移入空穴，这样就把空穴向下推了一层。重复该步骤直到 X 可以被放入空穴。所以最坏为 O(logN)。

    //删除最小元素
    void deleteMin()
    {
        if(isEmpty())
            throw UnderflowException();

        //下标为 1 的位置是堆的起始位置
        array[1] = array[currentSize--];
        percolateDown(1);
    }
    //删除最小元素，放入 minItem 中
    void deleteMin(Comparable & minItem)
    {
        if(isEmpty())
            throw UnderflowException();

        minItem = array[1];
        array[1] = array[currentSize--];
        percolateDown(1);
    }

    //下滤， hole 是下滤的起始位置
    void percolateDown(int hole)
    {
        int child;
        Comparable tmp = array[hole];
        
        for( ; hole*2 <= currentSize; hole = child)
        {
            child = hole * 2;
            if(child != currentSize && array[child + 1] < array[child])
                child++;    //换成右子树
            
            if(array[child] < tmp)
                array[hole] = array[child];
            else
                break;
        }
        
        array[hole] = tmp;
    }

如下是一个删除最小值过程：

初始操作：buildHeap

这种操作有两种方法，一种是对每个元素进行 insert 操作，因为插入最好的时间 O(1)，最坏为 O(logN)，所以这种最好时间为 O(N)，最坏 O(NlogN)。一种是将 N 个元素以任意顺序放入树中，然后下滤非叶结点。由于非叶结点一般为 $\left \lfloor N/2 \right \rfloor$ ，所以最坏的情况下下滤总次数为： $\sum_{i=0}^{h-1}2^{i}*(h-i)$ ，h 为高度。可以知道这个值为 $S=2^{h+1}-1-(h+1)$ ，而 N 的最大值： $N=2^{h+1}-1$ ，所以这种构造的时间为 O(N)。

    explicit BinaryHeap(const vector<Comparable> & items)
        : array(items.size()+10), currentSize(items.size())
    {
        for(int i=0; i<items.size(); i++)
            array[i+1] = items[i];
        buildHeap();
    }

    void buildHeap()
    {
        for(int i=currentSize/2; i>0; i--)
            percolateDown(i);
    }

d堆

d 堆与二叉堆很像，但其所有的结点都有 d 个儿子，因此二叉堆记为 2 堆。

因为有很多情形是插入比删除操作多得多，这种树就派上用场了。d 堆将 insert 操作运行时间改为 O( $log_{d}N$ )，然而对于 deleteMin 操作，因为要进行 d-1 次比较，所以时间为 O( $d*log_{d}N$ )。而且找到儿子和父亲的乘法和除法都有个因子 d ，除非 d 是 2 的幂，不然不能通过二进制的移位来实现除法而导致运行时间急剧增加。

如下是一个 3 堆：

左式堆

由于二叉堆的合并操作是比较困难的操作，所以这是一种方便合并操作的堆。我们把任意一个结点 X 的零路径长（null path length）npl(X) 规定为从 X 到一个不具有两个儿子的结点的最短路径的长。具有 0 个或 1 个儿子结点的 npl 为 0，而 npl(NULL) = -1 ，如下为两棵树的 npl 情况。

可以发现，任意结点的零路径长比它的诸儿子结点的零路径长的最小值多 1。这也适用于少于两个儿子的结点，因为 null 的零路径长是 -1。

左式堆：对于堆中的每一个结点 X，左儿子的零路径长至少与右儿子的零路径长一样大。对于左式堆，X 结点的零路径长度等于右儿子的零路径长度加 1。

因为左式堆趋向于加深左路径，所以右路径应该短，事实上沿左式堆右侧的右路径确实是该堆中最短路径。否则，就会存在一条路径通过某个结点 X ，取得左儿子（可能为空）的零路径长度小于右儿子的零路径长度。

定理：在右路径上有 r 个结点的左式树必然至少有 $2^{r}-1$ 个结点。

该定理说明，N 个结点的左式树有一条右路径最多含有 $\left \lfloor log(N+1) \right \rfloor$ 个结点。

下面是是实现：

方法一：合并操作（merge）采用递归操作

#ifndef LeftistHeap_H
#define LeftistHeap_H

#include <queue>
using namespace std;

template<typename Comparable>
class LeftistHeap
{
public:
    explicit LeftistHeap()
    {
        root = NULL;
    }
    explicit LeftistHeap(const vector<Comparable> & items)
    {
        for(int i=0; i<items.size(); i++)
        {
            LeftistHeap *heap = new LeftistHeap();
            heap->insert(items[i]);
            que.push(heap);
        }
        buildHeap();
    }

    bool isEmpty() const
    {
        if(root == NULL)
            return true;
        else
            return false;
    }

    //C++中千万不能返回局部对象的引用，因为返回引用之前已被析构
    const Comparable & findMin() const
    {
        if(isEmpty())
            throw UnderflowException();
        return root->element;
    }

    void insert(const Comparable & x)
    {
        //插入操作变为一个结点和该堆的合并
        root = merge(new LeftNode(x), root);
    }

    //删除最小元素
    void deleteMin()
    {
        if(isEmpty())
            throw UnderflowException();

        LeftNode *oldRoot = root;
        root = merge(root->left, root->right);
        delete oldRoot;
    }
    //删除最小元素，放入 minItem 中
    void deleteMin(Comparable & minItem)
    {
        if(isEmpty())
            throw UnderflowException();

        minItem = findMin();
        deleteMin();
    }
    void makeEmpty();

    //合并 rhs堆 到本堆
    void merge(LeftistHeap & rhs)
    {
        if(this == &rhs)
            return;

        root = merge(root, rhs.root);
        rhs.root = NULL;
    }

    const LeftistHeap & operator=( const LeftistHeap & rhs);

private:
    struct LeftNode
    {
        Comparable  element;
        LeftNode *  left;
        LeftNode *  right;
        int         npl;
        LeftNode( const Comparable &theElement, LeftNode *lt = NULL,
                  LeftNode *rt = NULL, int np = 0)
            :element(theElement), left(lt), right(rt), npl(np){}
    };

    LeftNode *root;
    queue<LeftistHeap *> que;   //存放堆的队列

    LeftNode * merge(LeftNode *h1, LeftNode *h2)
    {
        if(h1 == NULL) return h2;
        if(h2 == NULL) return h1;
        if(h1->element < h2->element)
            return merge1(h1, h2);
        else
            return merge1(h2, h1);
    }

    //内部合并函数，h1->element < h2->element
    LeftNode * merge1(LeftNode *h1, LeftNode *h2)
    {
        if(h1->left == NULL)    //一个结点的堆的合并
            h1->left = h2;
        else
        {
            h1->right = merge(h1->right, h2);   //h1 左结点非空就合并右结点和 h2
            if(h1->left->npl < h1->right->npl)  //每层递归操作完成后检查该层根结点孩子的零路径长度
                swapChildren(h1);   //不符合左式堆的时候就交换左右孩子
            h1->npl = h1->right->npl + 1; //根结点 npl = min_npl(h1->left, h1->right) + 1,
                                          //但是左式堆的左结点的npl一定大于或等于右结点
        }
    }

    void swapChildren(LeftNode *t)
    {
        LeftNode *tmp = t->left;
        t->left = t->right;
        t->right = tmp;
    }
    void reclaimMemory(LeftNode *t)
    {
        if(t)
            delete t;
    }
    LeftNode * clone(LeftNode *t) const
    {
        LeftNode *node = new LeftNode(t->element,
                                      t->left, t->right, t->npl);
        return node;
    }

    void buildHeap()
    {
        while (que.size() > 1) {
            LeftistHeap *h1 = que.front();
            que.pop();
            LeftistHeap *h2 = que.front();
            que.pop();
            h1->merge(h2);
            que.push(h1);
        }
        LeftistHeap *heap = que.front();
        que.pop();
        this->merge(heap);
    }
};

#endif // LeftistHeap_H

步骤如下：

方法二：合并操作（merge）非递归

先通过合并两个堆的右路径建立一棵新的树，如下

我们可以看到右路径以排序的方式安排，且保持它们各自的左儿子不变。然后交换该路径上左式堆性质被破坏的结点的两个儿子。这就是非递归实现的方法。因为可能由于结点很多，而导致递归实现缺乏栈空间，所以该方法适合于大型数据堆合并。

递归的方法的合并操作的时间与右路径的长成正比，合并两个左式堆的时间界为 O(logN)。同理插入，删除都是 O(logN)。

斜堆

首先，斜堆是具有堆序性质的二叉树，但是没有树的结构限制。而左式堆也是具有堆序性质的二叉树，但是要求 npl(leftChild) >= npl(rightChild)。所以不用保留结点的 npl 信息。除此之外，和左式堆没有区别。斜堆的右路径可以任意长。斜堆的基本操作也是合并（merge），只不过交换孩子结点是每次递归操作后都有的。看下面的代码

    //内部合并函数，h1->element < h2->element
    LeftNode * merge1(LeftNode *h1, LeftNode *h2)
    {
        if(h1->left == NULL)    //一个结点的堆的合并
            h1->left = h2;
        else
        {
            h1->right = merge(h1->right, h2);   //h1 左结点非空就合并右结点和 h2
            swapChildren(h1);  //每层递归操作完成后就交换左右孩子
        }
    }

我们会发现，每个子树的右路径的所有结点的最大者不交换左右儿子，这是因为它的右儿子必定为空。这也是由这段代码决定的，因为我们的合并操作，总是先考虑到左孩子是否为空，为空就放在左边，所以不存在这样的结点它只有右孩子。所以右路径的最大结点要么没有孩子，要么只有左孩子。没有孩子时最后执行 “h1->left = h2” 跳出递归，有左孩子时，交换后，那么右路径最大结点变为其原来的左孩子，它是没有孩子结点的，当然也符合上面的结论。

斜堆的插入、删除、合并也是 O(logN)。

二项队列

虽然左式堆和斜堆都以每次操作花费 O(logN) 时间有效地支持合并、插入和 deletMin，二叉堆以每次操作花费常数时间支持插入。二项队列支持所有这三种操作，每次操作的最坏情形运行时间为 O(logN)，而插入操作平均花费常数时间。

二项队列不是一颗堆序的树，而是堆序的树的集合，称为森林。这个集合中的每一棵树都是有约束的形式，他们叫做二项树。

下面定义二项树：高度为 0 的二项树是一颗单结点树；高度为 k 的二项树 $B_{k}$ 通过将一颗二项树 $B_{k-1}$ 附接到另一颗二项树 $B_{k-1}$ 的根上而构成。下图显示二项树 $B_{0},B_{1},B_{2},B_{3},B_{4}$ :

可见，二项树 $B_{k}$ 由一个带有儿子 $B_{0},B_{1},...,B_{k-1}$ 的根组成。高度为 k 的二项树恰好有 $2^{k}$ 个结点，其在深度 d 处的结点数是二项系数 $C_{k}^{d}$ 。

二项队列要求其集合中的二项树在任意高度上最多只有一颗，并且这些二项树是有堆序要求的。我们表示大小为 13 的优先队列可以用森林 $\begin{Bmatrix} B_{3},&B_{2}, & B_{0} \end{Bmatrix}$ 表示。我们把这种表示写成 1101，它不仅以二进制表示了 13，而且也表示这样的事实：在上述表示中， $B_{0},B_{2},B_{3}$ 出现，而 $B_{1}$ 则没有出现。

如下是具有 6 个元素的优先队列 $H_{1}$ ：

二项队列操作

（1）最小元可以通过搜索所有树的根找出。由于最多有 log(N+1) 棵不同的树，因此最小元可以以 O(log(N+1)) 时间找到。

（2）合并操作也很容易，基本上是通过两个队列加到一起来完成的。下面通过一个例子介绍：

如下两个二项队列合并，二项队列最好是按照高度排序好的，这样更有效：

首先，令 $H_{3}$ 是新的二项队列，由于 $H_{1}$ 中没有高度为 0 的二项树而 $H_{2}$ 有，因此将该二项树作为 $H_{3}$ 的一部分。然后将两个高度为 1 的二项树相加（大根成为小根的子树）从而建立了一个高度为 2 的二项树，如下

这样， $H_{3}$ 中将没有高度为 1 的二项树。现在存在 3 棵高度为 2 的树：我们将一颗高度为 2 的二项树放到 $H_{3}$ 中并合并其他两个二项树。由于 $H_{1},H_{2}$ 中没有高度为 3 的二项树，因此该二项树就成为 $H_{3}$ 的一部分，合并结束。如下

由于总共最多存在 O(log(N+1)) 棵二项树，因此合并在最坏情形下花费时间为 O(log(N+1))。

（3）插入实际上就是特殊情形的合并，只要创建一颗单结点树并执行一次合并即可。

最坏情形运行时间为 O(logN)，由于二项队列中每棵树出现的概率为 1/2，于是我们预计插入操作在两步之后终止，因此平均时间是常数。

$T_{n} = \frac{1}{2}\times 1+\frac{1}{2}\times(\frac{1}{2}\times2+\frac{1}{2}\times(\frac{1}{2}\times3+\frac{1}{2}\times(\frac{1}{2}\times...)))$

$T_{n} = 2-n\cdot (\frac{1}{2})^{n}$

（4）deleteMin 可以通过首先找出一颗具有最小根的二项树来完成。设该树为 $B_{k}$ ，并令原来的优先队列为 H，我们从 H 中去除 $B_{k}$ 形成 $H^{'}$ 。再去除 $B_{k}$ 的根，得到一些二项树 $B_{0},B_{1},...,B_{k-1}$ ，他们共同形成优先队列 $H^{''}$ 。合并 $H^{'}$ 和 $H^{''}$ 即可。整个花费为 2*O(logN) 的时间。

二项队列的实现

二项树的每一个结点包含数据、第一个儿子以及右兄弟。

以下为二项队列类架构及结点定义

#ifndef BINOMIALQUEUE_H
#define BINOMIALQUEUE_H

template <typename Comparable>
class BinomialQueue
{
public:
    BinomialQueue();
    BinomialQueue(const Comparable & item);
    BinomialQueue(const BinomialQueue & rhs);
    ~BinomialQueue();

    bool isEmpty() const;
    const Comparable & findMin() const;

    void insert(const Comparable & x);
    void deleteMin();
    void deleteMin(Comparable & minItem);

    void makeEmpty();
    void merge(BinomialQueue & rhs);

    const BinomialQueue & operator= (const BinomialQueue & rhs);

private:
    struct BinomialNode
    {
        Comparable element;
        BinomialNode *leftChild;
        BinomialNode *nextSibling;
        BinomialNode( const Comparable & theElement,
                      BinomialNode *lt, BinomialNode *rt)
            :element(theElement), leftChild(lt), nextSibling(rt){}
    };

    enum{ DEFAULT_TREES = 1 };

    int currentSize; // number of items in priorty queue
    vector<BinomialNode *> theTrees; // an array of tree roots

    int findMinIndex() const;
    int capacity() const;
    BinomialNode * combineTrees(BinomialNode *t1, BinomialNode *t2);
    void makeEmpty(BinomialNode *& t);
    BinomialNode * clone(BinomialNode *t) const;
};

#endif // BINOMIALQUEUE_H

合并操作只涉及到同样高度的两个二项树的合并操作，所以以下代码是合并两个同样大小的二项树程序代码：

    BinomialNode * combineTrees(BinomialNode *t1, BinomialNode *t2)
    {
        if(t2->element < t1->element)
            return combineTrees(t2, t1);
        t2->nextSibling = t1->leftChild;
        t1->leftChild = t2;
        return t1;
    }

合并两个优先队列的程序代码：

    // merge rhs into the priority queue. rhs becomes empty.
    // carry is previous step's reslut.
    void merge(BinomialQueue & rhs)
    {
        if(this == &rhs)
            return;

        currentSize += rhs.currentSize;

        if(currentSize > capacity())
        {
            int oldNumTrees = theTrees.size();
            int newNumTrees = max(theTrees.size(), rhs.theTrees.size()) + 1;
            theTrees.resize(newNumTrees);
            for(int i=oldNumTrees; i<newNumTrees; i++)
                theTrees[i] = NULL;
        }

        BinomialNode *carry = NULL;
        for(int i=0, j=1; j<=currentSize; i++, j*=2)
        {
            BinomialNode *t1 = theTrees[i];
            BinomialNode *t2 = i<rhs.theTrees.size() ? rhs.theTrees[i] : NULL;

            int whichCase = t1==NULL ? 0 : 1;
            whichCase += t2==NULL ? 0 : 2;
            whichCase += carry==NULL ? 0 : 4;
            
            switch (whichCase) {
            case 0: // no trees
            case 1: // only this
                break;
            case 2: // only rhs
                theTrees[i] = t2;
                rhs.theTrees[i] = NULL;
                break;
            case 4: // only carry
                theTrees[i] = carry;
                carry = NULL;
                break;
            case 3: // this and rhs
                carry = combineTrees(t1, t2);
                theTrees[i] = rhs.theTrees[i] = NULL;
                break;
            case 5: // this and carry
                carry = combineTrees(t1, carry);
                theTrees[i] = NULL;
                break;
            case 6: // rhs and carry
                carry = combineTrees(t2, carry);
                rhs.theTrees[i] = NULL;
                break;
            case 7: // this rhs and carry
                theTrees[i] = carry;
                carry = combineTrees(t1, t2);
                rhs.theTrees[i] = NULL;
                break;
            default:
                break;
            }
        }
        
        for(int k=0; k<rhs.theTrees.size(); k++)
            rhs.theTrees[k] = NULL;
        rhs.currentSize = 0;
    }

以下为 deleteMin 程序代码：

    void deleteMin(Comparable & minItem)
    {
        if(isEmpty())
            throw UnderflowException();
        
        int minIndex = findMinIndex();
        minItem = theTrees[minIndex]->element;
        
        BinomialNode *oldRoot = theTrees[minIndex];
        BinomialNode *deletedTree = oldRoot->leftChild;
        delete oldRoot;
        
        // construct H"
        BinomialQueue deletedQueue;
        deletedQueue.theTrees.resize(minIndex + 1);
        deletedQueue.currentSize = (1 << minIndex) - 1;
        for(int j=minIndex - 1; j>=0; j--)
        {
            deletedQueue.theTrees[j] = deletedTree;
            deletedTree = deletedTree->nextSibling;
            deletedQueue.theTrees[j]->nextSibling = NULL;
        }
        
        // construct H'
        theTrees[minIndex] = NULL;
        currentSize -= deletedQueue.currentSize + 1;
        
        merge(deletedQueue);
    }

    // find index of tree containing the smallest item in the priority queue.
    // the priority queue must not be empty.
    // return the index of tree containing the smallest item.
    int findMinIndex() const
    {
        int i;
        int minIndex;
        
        for(i=0; theTrees[i]==NULL; i++)
            ;
        
        for(minIndex=i; i<theTrees.size(); i++)
            if(theTrees[i] != NULL && 
                    theTrees[i]->element < theTrees[minIndex]->element)
                minIndex = i;
        
        return minIndex;
    }

标准库中的优先队列

在 STL 中，二叉堆是通过称为 priority_queue 的类模板实现的，该模板在标准头文件 queue 中找到。只不过 STL 实现一个最大堆而不是最小堆，于是所访问的项就是最大项。使用 greater 函数对象作为比较器可以得到最小堆。

堆中元素重复是允许的，删除也只删除一个。

以下为最大堆和最小堆的一个例程：

#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#include <string>
using namespace std;

// empty the priority queue and print its contents
template <typename PriorityQueue>
void dumpContents(const string & msg, PriorityQueue & pq)
{
    cout << msg << ":" << endl;
    while (!pq.empty()) {
        cout << pq.top() << endl;
        pq.pop();
    }
}

int main()
{
    priority_queue<int> maxPQ;
    priority_queue<int, vector<int>, greater<int> > minPQ;
    
    minPQ.push(4); minPQ.push(3); minPQ.push(5);
    maxPQ.push(4); maxPQ.push(3); maxPQ.push(5);
    
    dumpContents("minPQ", minPQ); // 3 4 5
    dumpContents("maxPQ", maxPQ); // 5 4 3
    return 0;
}

huihuiwith

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【数据结构与算法】第6章优先队列（堆）

目录二叉堆d堆左式堆斜堆二项队列标准库中的优先队列具有特殊优先级的队列叫做优先队列。像操作系统中，调度算法往往会使用优先队列结构。优先队列至少允许下列两种操作：insert，deleteMin（找出、返回和删除优先队列中的最小项）。二叉堆下面将讨论其结构性质和堆序性质。（1）结构性质二叉堆是一棵被完全填满的二叉树（即完全二叉树），可能的例外是在底层，底层...
复制链接

扫一扫