最小最大堆的C++实现

已于 2024-08-20 01:48:36 修改
阅读量208 收藏
点赞数 1
文章标签： c++ 算法 数据结构
于 2024-06-09 00:46:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/139553454
版权

最小最大堆是一种双端优先队列，用完全二叉树的二叉堆结构存放关键字，该数据结构的详细介绍见
数据结构(C语言版) Ellis Horowitz Sartaj Sahni Susan Anderson-Freed 著 李建中 张岩 李治军译
机械工业出版社 p274-p278
这里仅给出C++实现

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <ctime>
#include <utility>
using namespace std;

template <typename T>
struct MaxMin
{
	T Max;
	T Min;
	bool isMinMaxHeap;
	MaxMin(const T& Max, const T& Min, bool i) :Max(Max), Min(Min), isMinMaxHeap(i) {}
	MaxMin() = default;
};

template <typename T>
class MinMaxHeap //T只提供小于，其余用运算符重载
{
public:
	size_t getSize() { return _heap.size(); }
	T& _at(size_t index)
	{
		if (index >= _heap.size())
			return NULLVALUE;
		return _heap[index];
	}
	bool isEmpty() { return _heap.empty(); }
	bool isMinLevel(size_t i);
	void insert(const T &key);
	bool removeMinValue(T& key);
	bool removeMaxValue(T& key);
	bool changeValue(const T &key, size_t index);
	bool Delete(size_t index);
	MaxMin<T> isMinMaxHeap(size_t cur, bool isMinlevel);
	MinMaxHeap(const vector<T>& input, const T &v);
	bool natureMaintain()
	{
		if (isEmpty())
			return true;
		return isMinMaxHeap(0, true).isMinMaxHeap;
	}
private:
	T Min_value;
	T NULLVALUE;
	pair<size_t, bool> insert_adjust(bool isMinmiumLevel, size_t cur, const T& key);
	static bool less(const T& left, const T& right, bool d)
	{
		if (d)
		{
			return left < right;
		}
		else
		{
			return left > right;
		}
	}

	static bool lessEqual(const T& left, const T& right, bool d)
	{
		return less(left, right, d) || left == right;
	}
	void insertToHeapRootEmpty(size_t root, T key, bool d);
	vector<T> _heap;
};

template <typename T>
bool MinMaxHeap<T>::Delete(size_t index)
{
	if (index >= _heap.size())
	{
		cout << "Error,invaild index" << endl;
		return false;
	}
	changeValue(Min_value, index);
	removeMinValue(Min_value);
	return true;
}

template <typename T>
bool MinMaxHeap<T>::changeValue(const T& key, size_t index)
{
	if (key < Min_value)
	{
		cout << "invaild value" << endl;
		return false;
    }

	if (index >= _heap.size())
	{
		cout << "Error,invaild index" << endl;
		return false;
	}

	if (_heap[index] == key)
		return true;

	bool atMinlevel = isMinLevel(index);
	if (atMinlevel && _heap[index] < key || (!atMinlevel) && _heap[index] > key)
	{
		auto _pair = insert_adjust(atMinlevel, index + 1, key);
		insertToHeapRootEmpty(index, _heap[index], atMinlevel);
		insertToHeapRootEmpty(_pair.first - 1, key, _pair.second);
	}
	else
	{
		insert_adjust(atMinlevel, index + 1, key);
		if (index == 0)
			_heap[0] = key;
	}
	return true;
}

template <typename T>
MinMaxHeap<T>::MinMaxHeap(const vector<T>& input, const T& v):_heap(input), Min_value(v)
{
	for (auto run = input.cbegin(); run != input.cend(); ++run)
	{
		if (*run < Min_value)
		{
			cout << "Error,invaild value" << endl;
			exit(-1);
		}
	}

	size_t left_most = 1;
	size_t k = 0;
	for (; (left_most << 1) <= _heap.size(); left_most <<= 1) ++k;

	left_most >>= 1;
	bool in_Min_level;
	if (k % 2 == 1)
		in_Min_level = true;
	else
		in_Min_level = false;
	for (size_t run = _heap.size() >> 1; run > 0; --run)
	{
	    insertToHeapRootEmpty(run - 1, _heap[run - 1], in_Min_level);
		if (run == left_most)
		{
			in_Min_level = !in_Min_level;
			left_most >>= 1;
		}
	}
}

template <typename T>
bool MinMaxHeap<T>::isMinLevel(size_t i)
{
	size_t l = i + 1;
	size_t run = 1;
	bool isMinLevel = true;
	while ((run = run << 1) <= l)
	{
		if (isMinLevel)
		{
			isMinLevel = false;
		}
		else
		{
			isMinLevel = true;
		}
	}
	return isMinLevel;
}

template <typename T>
pair<size_t, bool> MinMaxHeap<T>::insert_adjust(bool isMinmiumLevel, size_t cur, const T &key)
{
	if (cur == 1)
		return { 1, true };
	bool testMinLevel;
	if (_heap[cur / 2 - 1] < key)
	{
		testMinLevel = false;
	}
	else
	{
		testMinLevel = true;
	}

	size_t sub = cur;
	cur /= 2;
	while (cur > 0)   
	{
		if (isMinmiumLevel)
		{
			if (testMinLevel == false)
			{
				if (_heap[cur - 1] < key)
				{
					_heap[sub - 1] = _heap[cur - 1];
					sub = cur;
				}
				else
				{
					_heap[sub - 1] = key;
					break;
				}
			}
			else
			{
				if (cur / 2 == 0)
				{
					_heap[sub - 1] = key;
					return { sub, true };
				}
			}
			isMinmiumLevel = false;
		}
		else
		{
			if (testMinLevel == true)
			{
				if (_heap[cur - 1] > key)
				{
					_heap[sub - 1] = _heap[cur - 1];
					sub = cur;
				}
				else
				{
					_heap[sub - 1] = key;
					break;
				}
			}
			else
			{
				if (cur / 2 == 0)
				{
					_heap[sub - 1] = key;
					return { sub, false };
				}
			}
			isMinmiumLevel = true;
		}
		cur /= 2;
	}

	if (cur == 0)
	{
		_heap[sub - 1] = key;
		return { sub, isMinmiumLevel };
	}
	else
	{
		if (sub / 2 == cur)
			return { sub, isMinmiumLevel };
		else
			return { sub, testMinLevel };
	}
}

template <typename T>
void MinMaxHeap<T>::insert(const T &key)
{
	if (key < Min_value)
	{
		cout << "Error, invaild value" << endl;
		return;
	}
	if (_heap.empty())
	{
		_heap.push_back(key);
		return;
	}

	_heap.push_back(key);  
	size_t cur = _heap.size();
	bool isMinmiumLevel = isMinLevel(cur - 1);
	insert_adjust(isMinmiumLevel, cur, key);
}

template <typename T>
bool MinMaxHeap<T>::removeMaxValue(T& key)
{
	if (_heap.empty())
	{
		return false;
	}

	if (_heap.size() == 1)
	{
		key = _heap[0];
		_heap.pop_back();
		return true;
	}

	size_t max;
	max = 1;
	if (3 <= _heap.size() && _heap[2] > _heap[max])
	{
		max = 2;
	}

	key = _heap[max];
	if (max + 1 == _heap.size())
	{
		_heap.pop_back();
		return true;
	}

	T re_insert = _heap.back();
	_heap.pop_back();
	insertToHeapRootEmpty(max, re_insert, false);
	return true;

}

template <typename T>
bool MinMaxHeap<T>::removeMinValue(T& key)
{
	if (_heap.empty())
	{
		return false;
	}

	if (_heap.size() == 1)
	{
		key = _heap[0];
		_heap.pop_back();
		return true;
	}

	key = _heap[0];
	T re_insert = _heap.back();
	_heap.pop_back();
	insertToHeapRootEmpty(0, re_insert, true);
	return true;
}

template <typename T>
void MinMaxHeap<T>::insertToHeapRootEmpty(size_t root, T key, bool d)
{
	while (true)
	{
		size_t _root = root + 1;
		if (_root * 2 > _heap.size())
		{
			_heap[root] = key;
			break;
		}

		size_t left = _root * 2;
		size_t second_smallest_or_largest;
		if (2 * left <= _heap.size())
		{
			second_smallest_or_largest = 2 * left - 1;

			if (2 * left + 1 <= _heap.size() && less(_heap[2 * left], _heap[second_smallest_or_largest], d))
			{
				second_smallest_or_largest = 2 * left;
			}

			if (2 * (left + 1) <= _heap.size())
			{
				if (less(_heap[2 * left + 1], _heap[second_smallest_or_largest], d))
				{
					second_smallest_or_largest = 2 * left + 1;
				}

				if (2 * (left + 1) + 1 <= _heap.size() && less(_heap[2 * (left + 1)], _heap[second_smallest_or_largest], d))
				{
					second_smallest_or_largest = 2 * (left + 1);
				}
			}
			else
			{
				if (less(_heap[left], _heap[second_smallest_or_largest], d))
				{
					second_smallest_or_largest = left;
				}
			}
		}
		else
		{
			second_smallest_or_largest = left - 1;
			if (left + 1 <= _heap.size() && less(_heap[left], _heap[second_smallest_or_largest], d))
			{
				second_smallest_or_largest = left;
			}
		}

		if (lessEqual(key, _heap[second_smallest_or_largest], d))
		{
			_heap[root] = key;
			break;
		}

		if (second_smallest_or_largest + 1 == 2 * _root || second_smallest_or_largest == 2 * _root)
		{
			_heap[root] = _heap[second_smallest_or_largest];
			_heap[second_smallest_or_largest] = key;
			break;
		}

		_heap[root] = _heap[second_smallest_or_largest];
		size_t parent = (second_smallest_or_largest + 1) / 2;
		if (less(_heap[parent - 1], key, d))
		{
			swap(_heap[parent - 1], key);
		}
		root = second_smallest_or_largest;
	}
}

template <typename T>
MaxMin<T> MinMaxHeap<T>::isMinMaxHeap(size_t cur, bool isMinlevel)
{
	size_t _cur = cur + 1;
	if (2 * _cur > _heap.size())
	{
		return MaxMin<T>(_heap[cur], _heap[cur], true);
	}

	MaxMin<T> temp;
	temp.isMinMaxHeap = false;
	MaxMin<T> result = isMinMaxHeap(2 * _cur - 1, isMinlevel ? false : true);
	if (result.isMinMaxHeap)
	{
		if (2 * _cur + 1 <= _heap.size())
		{
			MaxMin<T> result2 = isMinMaxHeap(2 * _cur, isMinlevel ? false : true);
			if (result2.isMinMaxHeap)
			{
				if (isMinlevel)
				{
					if (_heap[cur] <= result.Min && _heap[cur] <= result2.Min)
					{
						return MaxMin<T>(max(result.Max, result2.Max), _heap[cur], true);
					}
					else
					{
						cout << "节点" << _cur << "不是其子树中的最小值" << endl;
					}
				}
				else
				{
					if (_heap[cur] >= result.Max && _heap[cur] >= result2.Max)
					{
						return MaxMin<T>(_heap[cur], min(result.Min, result2.Min), true);
					}
					else
					{
						cout << "节点" << _cur << "不是其子树中的最大值" << endl;
					}
				}
			}
		}
		else
		{
			if (isMinlevel)
			{
				if (_heap[cur] <= result.Min)
				{
					return MaxMin<T>(result.Max, _heap[cur], true);
				}
				else
				{
					cout << "节点" << _cur << "不是其子树中的最小值" << endl;
				}
			}
			else
			{
				if (_heap[cur] >= result.Max)
				{
					return MaxMin<T>(_heap[cur], result.Min, true);
				}
				else
				{
					cout << "节点" << _cur << "不是其子树中的最大值" << endl;
				}
			}
		}
	}
	return temp;
}

int main()
{
	const int N = 10000;
	vector<int> input(N);
	for (int j = 0; j < N; ++j)
	{
		input[j] = j + 1;
	}
	shuffle(input.begin(), input.end(), default_random_engine());
	MinMaxHeap<int> obj(input, -200000);

	for (; obj.isEmpty() == false;)
	{
		size_t j;
		if (obj.getSize() == 1)
		{
			j = 1;
		}
		else
		{
			j = rand() % obj.getSize() + 1;
		}

		cout << "删除下标" << j << "元素" << endl;
		obj.Delete(j - 1);
		if (obj.natureMaintain())
		{
			cout << "最小最大堆性质维持" << endl;
		}
		else
		{
			cout << "最小最大堆性质破坏!" << endl;
			exit(-1);
		}
	}

	/*const int N = 10000;
	for (size_t i = 1; i <= N; ++i)
	{
		vector<int> input(i);
		for (int j = 0; j < i; ++j)
		{
			input[j] = j + 1;
		}
		shuffle(input.begin(), input.end(), default_random_engine(time(nullptr)));

		MinMaxHeap<int> _heap(input, -1);
		if (_heap.natureMaintain())
		{
			cout << "最小最大堆性质维持" << endl;
		}
		else
		{
			cout << "最小最大堆性质破坏" << endl;
			exit(-1);
		}
	}*/


	for (const auto& run : input)
	{
		cout << "插入" << run << endl;
		obj.insert(run);
		if (obj.natureMaintain())
		{
			cout << "最小最大堆性质维持" << endl;
		}
		else
		{
			cout << "最小最大堆性质破坏" << endl;
			exit(-1);
		}
	}

	for (size_t i = 1; i <= N; ++i)
	{
		size_t j;
		if (obj.getSize() == 1)
		{
			j = 1;
		}
		else
		{
			j = rand() % obj.getSize() + 1;
		}

		for (int run = -20; run <= 20; ++run)
		{
			cout << "将下标" << j << "元素" << "增加" << run << endl;
			obj.changeValue(obj._at(j - 1) + run, j - 1);
			if (obj.natureMaintain())
			{
				cout << "增加后最小最大堆性质维持" << endl;
			}
			else
			{
				cout << "增加后最小最大堆性质破坏!" << endl;
				exit(-1);
			}
			obj.changeValue(obj._at(j - 1) - run, j - 1);
			if (obj.natureMaintain())
			{
				cout << "恢复后最小最大堆性质维持" << endl;
			}
			else
			{
				cout << "恢复后最小最大堆性质破坏!" << endl;
				exit(-1);
			}

		}
	}

	/*while (_heap.isEmpty() == false)
	{
		int key;
		_heap.removeMinValue(key);
		cout << "移除最小值" << key << endl;
		if (_heap.natureMaintain())
		{
			cout << "最小最大堆性质维持" << endl;
		}
		else
		{
			cout << "最小最大堆性质破坏" << endl;
			exit(-1);
		}
	}

	/*while (_heap.isEmpty() == false)
	{
		int key;
		_heap.removeMaxValue(key);
		cout << "移除最大值" << key << endl;
		if (_heap.natureMaintain())
		{
			cout << "最小最大堆性质维持" << endl;
		}
		else
		{
			cout << "最小最大堆性质破坏" << endl;
			exit(-1);
		}
	}*/
    return 0;
}
naturerun
关注
数据结构中的最小最大堆c++模板实现(高级数据结构)
12-26
最小最大堆只的是一颗最小层和最大层相互交替的完全二叉树,我的最小最大堆继承自完全二叉树类和双端有先队列类,用c++模板实现.实现的功能包括创建堆,插入元素,删除最大元素,删除最小元素,并且重载方便输出.输出使用...
代码c++ 最大堆最小堆
01-03
最大堆确保每个父节点的值都大于或等于其子节点的值，而最小堆则相反，每个父节点的值都小于或等于其子节点的值。这两种类型的堆在各种算法中都有应用，例如优先级队列、排序和合并操作。 给定的问题是关于如何有效...
前 K 个高频元素(最小堆+pair排序)
qq_42836930的博客
06-15 335
题目： 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。 题解： 题目要求时间复杂度要小于O(NlogN)，所以先排除快排之类的排序算法。 考虑到我们解决第k小元素时使用了堆这一数据结构，所以本题自然可以使用堆来解决，我们需要频率前k高的元素，堆的大小定为k，往大小为k的堆中插入一个元素O(logK)（堆为完全二叉树），那么n个数插入n次，时间复杂度O(NlongK) 小于 O(NlogN)，因而我们需要维护好频率与元素的对应关系，pair<int,int>将会是很方便的。 tips：
C++实现最大堆最小堆
qq_41687938的博客
08-18 2018
目录 堆和栈的区别 最大堆与最小堆 最大堆的操作 最大堆的插入操作 最大堆的弹出操作 最大堆的C++代码实现 最小堆概念 最小堆的插入操作 最小堆的弹出操作 最小堆的C++代码实现 最大堆最小堆的应用 1.priority_queue 2. STL 堆操作 堆和栈的区别 　　一、堆栈空间分配区别： 　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈； 　　2、堆（操作系统）： 一般由程序员分配释放， 若程序员不..
数据结构最小堆C++实现
Brillian123的博客
05-18 3666
#pragma once # include<iostream> using namespace std; int DefaultSize = 10; //定义最小堆默认存储数据的数目 //最小堆的头文件，包括类定义及接口的实现。 template <class T> class MinHeap { public: MinHeap(int sz = DefaultSize); //构造函数，建立空堆 ......
C++最小堆和最大堆实现
weixin_54720578的博客
03-15 866
最大最小堆在c++中相关的函数是：它们包含在头文件中1）make_heap（建堆）在容器范围内，就地建堆，保证最大(小)值在所给范围的最前面，其他值的位置不确定。可以有两个参数，也可以有三个参数，前两个参数是指向开始元素的迭代器和指向结束元素的下一个元素的迭代器。第三个参数（谓词）是可选的，不选默认大顶堆。我们可以自定义比较函数来设定小顶堆2）pop_heap（取出）将堆顶(所给范围的最前面)元素移动到所给范围的最后，并且将新的最大(小)值置于所给范围的最前面。
最小堆C++实现
My_Algorithm的博客
07-03 3510
最小堆是指在树中，存在一个结点而且该结点有儿子结点，该结点的data域值都小于其儿子结点的data域值，并且它是一个完全二叉树（不是满二叉树）。 这里使用静态数组存储完全二叉树，对于完全二叉树采用顺序存储表示，那么对于任意一个下标为i(1 ≤ i ≤ n)的结点： 父结点为：i / 2（i ≠ 1），若i = 1，则i是根节点。 左子结点：2i（2i ≤ n）， 若不满足则无左子结点。 右子结点：2i + 1(2i + 1 ≤ n)，若不满足则无右子结点。 最小堆的定义： class Mi.
c++实现最大堆和最小堆
qq_38231713的博客
03-12 2222
原文地址 添加链接描述 本文加了一点点补充 堆是具有以下特性的完全二叉树，每个结点的值都大于或等于其左右孩子结点的值，叫做最大堆；每个结点的值都小于或等于其左右孩子结点的值，叫做最小堆。 一、建堆 vector<int> nums = {9, 6, 2, 4, 7, 0, 1, 8, 3, 5}; 1、如果使用nums构建最大堆： make_heap(nums.begin(), nu...
最大堆、最小堆C++实现
几番风雨的专栏
06-23 1507
最近学习了最大堆、最小堆数据结构，这个并不难懂，但在编程、编写学习笔记时，发现有不少错误、理解不深刻，有比较多的细节需要注意的，特别是孩子节点的访问条件、几个节点之间的比较出了不少错误，但经过一番努力，终于解决了。下面是最大堆的实现过程 最大堆、最小堆 C++实现 最大堆概念：每个节点的值都大于其子节点的值的完全二叉树。 最小堆概念：每个节点的值都小于或等于其子节点的值的完全二叉树。   使用数...
C++使用priority_queue 实现最大最小堆
auccy的博客
03-06 1293
参考考资料：https://www.cnblogs.com/nirvana-phoenix/archive/2012/05/29/2524344.html 1.基本类型实现 #include <iostream> #include <vector> #include <queue> void log(const char* str) { std::cout << str; } void log(const int v) { std::cout .
C++ priority_queue 最大堆、最小堆的实现
m0_47587308的博客
04-22 527
C++ priority_queue 最大堆、最小堆的实现
C++实现最大堆和最小堆
qq_37941471的博客
08-19 8233
堆 堆数据结构是一种数组对象，它可以被视为一颗完全二叉树结构（或者也有可能是满二叉树） 最大堆： 任一结点的关键码均大于等于它的左右孩子的关键码，其中堆顶的元素最大。（任一路径中的元素升序排列） 最小堆： 任一结点的关键码均小于等于它的左右孩子的关键码，其中堆顶的元素最小。（任一路径中的元素升序排列） 已知父节点： 左孩子节点 = 2*父节点+1 右孩子节点 = ...
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 ...【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如最小堆示例和最大堆示例所示。 堆排序算法 2、
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1032
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 503
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 447
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1084
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 394
【代码】求n的阶乘的相反数（c语言）
C#测试调用Ghostscript.NET浏览PDF文件
gc_2299的博客
09-23 501
学习并测试调用Ghostscript.NET模块打开及浏览PDF文件的基本用法
用C++代码实现最小最大堆
04-23
可以通过下面的代码实现最小最大堆： ```c #include #include #define MAX_HEAP_SIZE 100 typedef struct Heap { int* data; int size; } Heap; Heap* create_heap() { Heap* heap = (Heap*)malloc(sizeof...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值