优先队列学习笔记

最新推荐文章于 2021-11-10 16:25:43 发布

云子谣

最新推荐文章于 2021-11-10 16:25:43 发布

阅读量193

点赞数 1

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/qq_36203083/article/details/104507643

版权

算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

优先队列学习(上)

本篇为优先队列学习笔记，优先队列与队列相似，但优先队列中的元素整体上是有序的。

在插入一个元素时，优先队列的有序状态有可能会被打破，使用从下到上的堆有序化进行重新排序，确定每个元素的优先级，删除一个元素时，有序状态也有可能被打破，使用使用从上到下的堆有序化进行重新排列，最终使优先队列重新回到有序状态。

想要构建一个优先队列，一个数组即可作为其载体。本次使用完全二叉树作为实现优先队列的方法，另外还给该二叉树规定为堆有序，使其变成二叉堆，用来方便地完成优先队列的基本操作————“删除最大元素”、“插入元素”。

  堆有序是指在二叉树中，每个父节点的优先级都比其两个子节点高或者相等。

基于以上认识，可以开始着手实现一个简单的优先队列了。

首先要做的就是维护一个数组，为了计算方便，该数组的第0个位置（即索引为0）不存储数据，第1个位置用于存储根结点数据，第2和第3个位置用于存储根节点的两个子节点的位置，第4和第5个位置用于存储第2个位置数据的两个子节点数据，第6和第7个位置用于存储第3个位置数据第两个子节点数据…

以此类推，可知第K个节点的父节点为数组第k/2个位置上的数据，而第K个节点的两个子节点的分别为数组第2k个位置以及第2k+1位置的数据。根据此存储数据方式，实际上可以很方便的对这个二叉树进行遍历，并更新其有序化状态。

在试图实现优先队列之前，先实现两个常用的交换和比较大小的内联函数

template<typename T>
inline void exch(vector<T> &a, int j, int k)
{
    swap(a[j], a[k]);
}
template<typename T>
inline bool pqless(vector<T> &a, int x, int y)
{
    if(a[x] <= a[y])
        return true;
    return false;
}

优先队列学习（下）

1.sink

接下来，写一个模版类来完成最基本的优先队列实现。

该类主要实现以下几个方法
sink(由上到下的堆有序化方法)、swim(由下到上的堆有序化方法)、insert（插入元素的方法）、delete（删除优先级最高元素的方法）、pqless（比较数据大小的方法）、exch（交换节点数据的方法）

sink 函数用于实现由上到下的堆有序方法，假设此时因为某节点的优先级变低，使得它的优先级比子节点优先级低，打破了原来的堆有序状态，需要对二叉树的此节点位置开始，从上到下依据优先级进行重新构建堆有序状态。若某K节点的优先级变低，比较它第两个子节点----第2k和第2k+1节点的大小，寻找这两个子节点中数据优先级最大的，这样做的原因是堆有序的规则，父节点必须大于等于它的子节点，在父节点的优先级发生变化而需要与子节点交换时，还应该继续遵守堆有序的规则，因此寻找两个子节点中优先级最高的作为可能的父节点,在成为父节点之前，还需要保证原先的父节点确实比这个父节点的较大的一个子节点小，具体算法下所示：

N = pq.size() -1;
while(2*k <= N
{
  j = 2*k;
  if((j < N) && pqless(pq, j, j+1))
  j++;
  if(!pqless(pq,k,j)) break;
  exch(pq, k, j);
  k = j;
  //继续从上到下遍历子节点，直到数组的边缘。
}

2.swim

swim 函数用于实现由下到上的堆有序方法，应用场景为当某节点的优先级变高，有可能破坏二叉堆的堆有序状态，需要从该节点开始，往上(数组中是向前)进行父节点遍历，直到恢复新的堆有序状态。实现过程比较简单，只需要比较父节点和该节点本身的优先级,具体实现方法如下所示：

N = pq.size()-1;
while ((k>1)&&!pqless(pq, k, k/2)
{
  exch(pq, k, k/2);
  k = k/2;
}

3.insert

插入一个元素，假设需要插入一个元素，一般情况下会破坏堆有序状态，选择从数组最后插入，即从二叉树的最底层插入一个元素，接着使该二叉堆恢复有序状态即可。


pq.push_back(val); //val 是一个新的数据
int NN = pq.size()-1;
swim(NN);

4.delete

删除一个优先级最高的元素，该方法是优先队列的基本方法。一般是将优先队列中最后一个元素与最高级元素交换，并从队列中删除最高级元素，然后将被交换到最高级节点的这个最后一个元素进行堆有序化，使得优先队列重新回到堆有序状态。具体方法如下所示：

T max = pq[1];
N = pq.size()-1;
exch(pq,1,N--);
pq.assign(pq.begin,pq.end()-1)
sink(1);
return max;

完成了以上几个方法，基本就解决了优先队列的基本操作实现，稍对代码进行调整，可在main函数中进行验证自己的优先队列实现。

MaxPQ<int> maxpq(5);
   MinPQ<int> minpq(5);
   maxpq.insert(1);
//    maxpq.print();
   maxpq.insert(2);
//    maxpq.print();
   maxpq.insert(3);
//    maxpq.print();
   maxpq.insert(4);
//    maxpq.print();
   maxpq.insert(5);
//    maxpq.print();
   minpq.insert(3);
   minpq.insert(1);
   minpq.insert(2);
   minpq.insert(4);
   minpq.insert(5);

   cout << maxpq.deleteMax() << " " << minpq.deleteMin() << endl;

  maxpq.print();
   cout << maxpq.deleteMax() << " " << minpq.deleteMin() << endl;
 maxpq.print();
   cout << maxpq.deleteMax() << " " << minpq.deleteMin() << endl;
  maxpq.print();
   cout << maxpq.deleteMax() << " " << minpq.deleteMin() << endl;
 maxpq.print();
   cout << maxpq.deleteMax() << " " << minpq.deleteMin() << endl;

   maxpq.print();
   minpq.print();

本次代码运行结果如下所示


vector容量1
插入元素：1
---------目前vector 内容---------
-----------Max当前优先队列内容----------
0 1 
-----------Max当前优先队列内容----------
0 1 
vector容量2
插入元素：2
---------目前vector 内容---------
-----------Max当前优先队列内容----------
0 1 2 
-----------Max当前优先队列内容----------
0 2 1 
vector容量3
插入元素：3
---------目前vector 内容---------
-----------Max当前优先队列内容----------
0 2 1 3 
-----------Max当前优先队列内容----------
0 3 1 2 
vector容量4
插入元素：4
---------目前vector 内容---------
-----------Max当前优先队列内容----------
0 3 1 2 4 
-----------Max当前优先队列内容----------
0 4 3 2 1 
vector容量5
插入元素：5
---------目前vector 内容---------
-----------Max当前优先队列内容----------
0 4 3 2 1 5 
-----------Max当前优先队列内容----------
0 5 4 2 1 3 
5 1
-----------Max当前优先队列内容----------
0 4 3 2 1 
4 2
-----------Max当前优先队列内容----------
0 3 1 2 
3 3
-----------Max当前优先队列内容----------
0 2 1 
2 4
-----------Max当前优先队列内容----------
0 1 
1 5
-----------Max当前优先队列内容----------
0 
-----------Min当前优先队列内容----------
0 5 4 3 2 1 
Program ended with exit code: 0

下面是完整代码

//
//  Priority_Queue_practise.hpp
//  Dat_Structure
//
//  Created by  云子谣 on 2020/2/20.
//  Copyright © 2020  云子谣. All rights reserved.
//

#ifndef Priority_Queue_practise_hpp
#define Priority_Queue_practise_hpp

#include <stdio.h>
#include <iostream>

#include <queue>




#endif /* Priority_Queue_practise_hpp */


using namespace std;




template<typename T>class MaxPQ
{
public:
    MaxPQ(int maxN);
    ~MaxPQ();
    bool isEmpty();
    void insert(T val);
    T deleteMax();
    void swim(int k);
    void sink(int k);

    friend void exch(vector<T> &a, int j, int k);
    friend bool pqless(T &a, int x, int y);
    void print();
private:
    vector<T> pq;
    int N = 0;

};

template<typename T> class MinPQ
{
public:
    MinPQ(int maxN);
    ~MinPQ();

    bool isEmpty();
    void insert(T val);
    T deleteMin();
    void swim(int k);
    void sink(int k);
    friend void exch(vector<T> &a, int j, int k);
    friend bool pqless(T &a, int x, int y);
    void print();
private:
    vector<T> pq;
    int N = 0;

};


template<typename T>
inline void exch(vector<T> &a, int j, int k)
{
    swap(a[j], a[k]);
}
template<typename T>
inline bool pqless(vector<T> &a, int x, int y)
{
    if(a[x] <= a[y])
        return true;
    return false;
}






template<typename T>MaxPQ<T>::MaxPQ(int maxN)
{
//  pq.assign(maxN+1, 0);
    pq.resize(1);
}
template<typename T>MaxPQ<T>::~MaxPQ()
{}

template<typename T> bool MaxPQ<T>::isEmpty()
{
    N = pq.size();
    if(N)
        return false;
    return true;
}
template<typename T> void MaxPQ<T>::insert(T val)
{
//    pq[++N] = val;
//    swim(N);
    auto i = val;
    //cout << "接收元素：" << i << endl;
    pq.push_back(i);
    int NN= pq.size()-1;
    cout << "vector容量" << NN << endl;
    cout << "插入元素：" << *(pq.end()-1)<< endl;
    cout << "---------目前vector 内容---------" << endl;
    print();
    swim(NN);
    print();
}
template<typename T> T MaxPQ<T>::deleteMax()
{
    N = pq.size()-1;
    T max = pq[1];
    exch(pq, 1, N--);// 交换最后一个元素和最大元素， 另N-1 代表 整个队列大小减一

    pq.assign(pq.begin(), pq.end()-1);
    sink(1);
    //pq.resize(N-1);
    return max;

}


template<typename T> void MaxPQ<T>::sink(int k)
{
    N = pq.size()-1;
    while (k*2 <= N)
    {
        int j = k*2;
        if((j < N) && pqless(pq, j, j+1))// 找k的两个子节点中最大的
        {
            j++;
        }
        if(!pqless(pq, k, j))
            break;
        exch(pq, k, j);
        k = j;
    }
}

template<typename T> void MaxPQ<T>::swim(int k)
{
    while((k>1)&&!pqless(pq, k, k/2))
    {
        exch(pq, k, k/2);
        k = k/2;
    }

}





template<typename T>MinPQ<T>::MinPQ(int maxN)
{
    pq.assign(maxN+1, 0);

}
template<typename T>MinPQ<T>::~MinPQ(){}
template<typename T> void MinPQ<T>::insert(T val)
{
    pq[++N] = val;
    //pq.push_back(val);
    swim(N);
}
template<typename T> bool MinPQ<T>::isEmpty()
{
    if(N) return false;
    return true;
}

template<typename T> T MinPQ<T>::deleteMin()
{
    T min = pq[1];
    exch(pq, 1, N--);
    //pq.erase(pq.end());
    //pq[N+1] = nullptr;
    sink(1);
    //pq.resize(N-1);
    return min;
}

template<typename T> void MinPQ<T>::sink(int k)
{
    while(k*2 <= N)
    {
        int j = k*2;
        if((j<N)&&!pqless(pq, j, j+1))
            j++;
        if(pqless(pq, k, j))
            break;
        exch(pq, k, j);
        k = j;
    }
}
template<typename T> void MinPQ<T>::swim(int k)
{
    while((k>1)&&!pqless(pq, k/2, k))
    {
        exch(pq, k/2, k);
        k = k/2;
    }
}

template<typename T> void MaxPQ<T>::print()
{
    cout << "-----------Max当前优先队列内容----------" << endl;
    for (auto& v : MaxPQ<T>::pq) {
        std::cout << v << " " << std::ends;
    }
    cout << endl;

}
template<typename T> void MinPQ<T>::print()
{
     cout << "-----------Min当前优先队列内容----------" << endl;
    for (auto& v : MinPQ<T>::pq) {
        std::cout << v << " " << std::ends;
    }
    cout << endl;

}
//
//054213
//04321
//0312
//021
//01

尚未未学习的相关算法：堆排序、基于索引的优先队列，待更新

云子谣

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
优先队列学习笔记

优先队列学习(上)本篇为优先队列学习笔记，优先队列与队列相似，但优先队列中的元素整体上是有序的。在插入一个元素时，优先队列的有序状态有可能会被打破，使用从下到上的堆有序化进行重新排序，确定每个元素的优先级，删除一个元素时，有序状态也有可能被打破，使用使用从上到下的堆有序化进行重新排列，最终使优先队列重新回到有序状态。想要构建一个优先队列，一个数组即可作为其载体。本次使用完全二叉树作为实现优...
复制链接

扫一扫