优先队列：索引最小优先队列、最小优先队列、最大优先队列（c++11）
优先队列：索引最小优先队列（c++11）、最小优先队列、最大优先队列
文章目录
-
- 优先队列：索引最小优先队列（c++11）、最小优先队列、最大优先队列
- 前言
- 一、索引最小优先队列的实现思路
-
- 1.1 步骤一：
- 1.2 步骤二：
- 1.3 步骤三
- 二、索引最小优先队列的API设计
- 三、索引最小优先队列代码
- 五、最小优先队列代码
- 六、最大优先队列代码
前言
最大优先队列和最小优先队列，他们可以分别快速访问到队列中的最大元素和最小元素，但是他们有一个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们，而索引最小优先队列和索引最大优先队列可以解决这一问题，这里拿索引最小优先队列举例：
一、索引最小优先队列的实现思路
1.1 步骤一：
- 存储数据时，给每一个数据元素关联一个整数，例如insert(int k, T t)，可以看做k是t关联的整数，那么我们的实现需要通过k这个值，快速获取到队列中t这个元素，因此k具有唯一性。
1.2 步骤二：
- 步骤一完以后的结果，虽然我们给每个元素关联了一个整数，并且可以使用这个整数快速获取到该元素，但是，items数组中的元素顺序是随机的，并不是堆有序的，所以，可以增加一个int类型数组pq来保存每个元素在items数组中的索引，pq数组需要堆有序，即对pq数据进行修改，符合堆的标准。
堆有序：items[pq[i]]小于等于items[pq[2i]]和items[pq[2i+1]]
1.3 步骤三
- 通过步骤二，我们发现，可以通过上浮算法和下沉算法做堆调整的时候，其实调整的是pq数组。如果需要对items中的元素进行修改，比如让items[0]=‘H’，就需要对pq中的数据做堆调整，而且是调整pq[9]中元素的位置，但是就会遇到一个问题，修改的是items数组中0索引处的值，如何才能快速的知道需要挑中pq[9]中元素的位置呢？
最直观的想法是遍历pq数组，拿出每一个元素和o做比较，但效率很低。 因此，可以另外增加一个数组qp，vector qp
用来存储pq的逆序。 在pq数组中：pq[1] = 6; 那么在qp数组中，把6作为索引，1作为值；即 qp[6] = 1;
当有了pq数组后，如果我们修改了items[0]=‘A’，那么久可以先通过索引0，在qp数组中找到qp的索引，qp[0]=9，那么直接调整pq[9]即可。
二、索引最小优先队列的API设计
三、索引最小优先队列代码
#include 
五、最小优先队列代码
- 算法原理自行百度或查看数据结构与算法一书
#include p1;//默认情况下是最大值优先队列
//priority_queue, less> p2;//最大值优先队列
//priority_queue, greater> p3;//最小值优先队列
template<class T>
class MinPriorityQueue
{
public:
MinPriorityQueue(int capacity);
~MinPriorityQueue();
// 获取队列中元素的个数
int size();
//判断队列是否为空
bool isEmpty();
//判断堆中索引i处的元素是否小于索引j处的元素
bool less(int i, int j);
// 交换堆中i索引和j索引处的值
void exch(int i, int j);
//往堆中插入一个元素
void insert(T t);
//删除堆中最大的元素，并返回这个最大元素
T delMix();
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
void swim(int k);
// 使用下浮算法，使索引k处的元素能在堆中处于一个正确的位置
void sink(int k);
protected:
private:
T* items = nullptr;
int len;
};
template<class T>
MinPriorityQueue<T>::MinPriorityQueue(int capacity) {
this->items = new T[capacity + 1]; // 0位置不存储元素
this->len = 0;
}
template<class T>
int MinPriorityQueue<T>::size() {
return len;
}
template<class T>
bool MinPriorityQueue<T>::isEmpty() {
return len == 0;
}
template<class T>
bool MinPriorityQueue<T>::less(int i, int j) {
return items[i] < items[j];
}
template<class T>
void MinPriorityQueue<T>::exch(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
template<class T>
void MinPriorityQueue<T>::insert(T t) {
items[++len] = t;
swim(len);
}
template<class T>
T MinPriorityQueue<T>::delMix() {
T minData = items[1];
exch(1, len);
T val;
items[len] = val; // 删除元素后置位空
len--;
sink(1);
return minData;
}
template<class T>
void MinPriorityQueue<T>::swim(int k) {
while (k > 1)
{
if (less(k, k / 2))
{
exch(k, k / 2);
}
k = k / 2;
}
}
template<class T>
void MinPriorityQueue<T>::sink(int k) {
while (2 * k <= len)
{
int minIndex;
if (2 * k + 1 <= len)
{
if (less(2 * k, 2 * k + 1))
{
minIndex = 2 * k;
}
else
minIndex = 2 * k + 1;
}
else
minIndex = 2 * k;
if (less(k, minIndex))
{
break;
}
exch(k, minIndex);
k = minIndex;
}
}
template<class T>
MinPriorityQueue<T>::~MinPriorityQueue() {
if (items != nullptr)
{
delete[] items;
items = nullptr;
}
}
int main()
{
MinPriorityQueue<string>* queue = new MinPriorityQueue<string>(10);
queue->insert("A");
queue->insert("B");
queue->insert("C");
queue->insert("D");
queue->insert("E");
queue->insert("F");
queue->insert("G");
while (!queue->isEmpty()) {
string maxData = queue->delMix();
cout << maxData << " ";
}
cout << endl;
delete queue;
system("pause");
return 0;
}
六、最大优先队列代码
- 算法原理自行百度或查看数据结构与算法一书
#include p1;//默认情况下是最大值优先队列
//priority_queue, less> p2;//最大值优先队列
//priority_queue, greater> p3;//最小值优先队列
template<class T>
class MaxPriorityQueue
{
public:
MaxPriorityQueue(int capacity);
~MaxPriorityQueue();
// 获取队列中元素的个数
int size();
//判断队列是否为空
bool isEmpty();
//判断堆中索引i处的元素是否小于索引j处的元素
bool less(int i, int j);
// 交换堆中i索引和j索引处的值
void exch(int i, int j);
//往堆中插入一个元素
void insert(T t);
//删除堆中最大的元素，并返回这个最大元素
T delMax();
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
void swim(int k);
// 使用下浮算法，使索引k处的元素能在堆中处于一个正确的位置
void sink(int k);
protected:
private:
T* items = nullptr;
int len;
};
template<class T>
MaxPriorityQueue<T>::MaxPriorityQueue(int capacity) {
this->items = new T[capacity + 1]; // 0位置不存储元素
this->len = 0;
}
template<class T>
int MaxPriorityQueue<T>::size() {
return len;
}
template<class T>
bool MaxPriorityQueue<T>::isEmpty() {
return len == 0;
}
template<class T>
bool MaxPriorityQueue<T>::less(int i, int j) {
return items[i] < items[j];
}
template<class T>
void MaxPriorityQueue<T>::exch(int i, int j) {
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
template<class T>
void MaxPriorityQueue<T>::insert(T t) {
items[++len] = t;
swim(len);
}
template<class T>
T MaxPriorityQueue<T>::delMax() {
T maxData = items[1];
exch(1, len);
T val;
items[len] = val; // 删除元素后置位空
len--;
sink(1);
return maxData;
}
template<class T>
void MaxPriorityQueue<T>::swim(int k) {
while (k > 1)
{
if (less(k / 2, k))
{
exch(k / 2, k);
}
k = k / 2;
}
}
template<class T>
void MaxPriorityQueue<T>::sink(int k) {
while (2 * k <= len)
{
int maxIndex;
if (2 * k + 1 <= len)
{
if (less(2 * k, 2 * k + 1))
{
maxIndex = 2 * k + 1;
}
else
maxIndex = 2 * k;
}
else
maxIndex = 2 * k;
if (!less(k, maxIndex))
{
break;
}
exch(k, maxIndex);
k = maxIndex;
}
}
template<class T>
MaxPriorityQueue<T>::~MaxPriorityQueue() {
if (items != nullptr)
{
delete[] items;
items = nullptr;
}
}
int main()
{
MaxPriorityQueue<string>* queue = new MaxPriorityQueue<string>(10);
queue->insert("A");
queue->insert("B");
queue->insert("C");
queue->insert("D");
queue->insert("E");
queue->insert("F");
queue->insert("G");
while (!queue->isEmpty()) {
string maxData = queue->delMax();
cout << maxData << " ";
}
cout << endl;
queue->insert("A");
queue->insert("B");
queue->insert("C");
queue->insert("D");
while (!queue->isEmpty()) {
string maxData = queue->delMax();
cout << maxData << " ";
}
cout << endl;
delete queue;
system("pause");
return 0;
}
