大小堆详解&C++实现&复杂度分析

已于 2023-11-24 20:26:23 修改
阅读量4.9k 收藏 23
点赞数 3
分类专栏： 算法与数据结构 C/C++ 文章标签： c++ java 开发语言
于 2018-07-13 21:53:08 首次发布
原文链接：https://www.cnblogs.com/skywang12345/p/3610187.html
版权

大小堆介绍部分转载自：二叉堆之图文解析

二叉堆的删除、复杂度分析和代码是自己写的~

堆和二叉堆的介绍

堆的定义

堆(heap)，这里所说的堆是数据结构中的堆，而不是内存模型中的堆。堆通常是一个可以被看做一棵树，它满足下列性质：
[性质一] 堆中任意节点的值总是不大于(不小于)其子节点的值；
[性质二] 堆总是一棵完全树。
将任意节点不大于其子节点的堆叫做最小堆或小根堆，而将任意节点不小于其子节点的堆叫做最大堆或大根堆。常见的堆有二叉堆、左倾堆、斜堆、二项堆、斐波那契堆等等。

二叉堆的定义

二叉堆是完全二元树或者是近似完全二元树，它分为两种：最大堆和最小堆。
最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。示意图如下：

二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。有时候，我们将"二叉堆的第一个元素"放在数组索引0的位置，有时候放在1的位置。当然，它们的本质一样(都是二叉堆)，只是实现上稍微有一丁点区别。
假设"第一个元素"在数组中的索引为 0 的话，则父节点和子节点的位置关系如下：
(01) 索引为i的左孩子的索引是 (2*i+1);
(02) 索引为i的右孩子的索引是 (2*i+2);（图中性质二有错，应该改为右孩子）
(03) 索引为i的父结点的索引是 floor((i-1)/2);

假设"第一个元素"在数组中的索引为 1 的话，则父节点和子节点的位置关系如下：
(01) 索引为i的左孩子的索引是 (2*i);
(02) 索引为i的右孩子的索引是 (2*i+1);（图中性质二有错，应该改为右孩子）
(03) 索引为i的父结点的索引是 floor(i/2);

注意：本文二叉堆的实现统统都是采用"二叉堆第一个元素在数组索引为0"的方式！

二叉堆的图文解析

在前面，我们已经了解到："最大堆"和"最小堆"是对称关系。这也意味着，了解其中之一即可。本节的图文解析是以"最大堆"来进行介绍的。

二叉堆的核心是"添加节点"和"删除节点"，理解这两个算法，二叉堆也就基本掌握了。下面对它们进行介绍。

1. 添加

假设在最大堆[90,80,70,60,40,30,20,10,50]种添加85，需要执行的步骤如下：

如上图所示，当向最大堆中添加数据时：先将数据加入到最大堆的最后，然后尽可能把这个元素往上挪，直到挪不动为止！
将85添加到[90,80,70,60,40,30,20,10,50]中后，最大堆变成了[90,85,70,60,80,30,20,10,50,40]。

void insertMaxHeap(int a, vector<int>& heap) {
	heap.push_back(a);
	int insertPos=heap.size()-1, parentPos=(insertPos-1)/2;
	while(parentPos>=0 && heap[parentPos]<heap[insertPos]) {
		swap(heap, insertPos, parentPos);
		insertPos=parentPos;
		parentPos=(insertPos-1)/2;
	}
}

void insertMinHeap(int a, vector<int>& heap) {
	heap.push_back(a);
	int insertPos=heap.size()-1, parentPos=(insertPos-1)/2;
	while(parentPos>=0 && heap[parentPos]>heap[insertPos]) {
		swap(heap, parentPos, insertPos);
		insertPos=parentPos;
		parentPos=(insertPos-1)/2;
	}
}

2. 删除

在网上看了很多资料，关于二叉堆删除，大部分都只涉及到堆顶元素的删除而没有考虑到堆中任意元素的删除，具体的原因可以参考知乎：为什么二叉堆只能删除堆顶元素？ - 知乎  简单来说就是因为二叉堆不支持查找元素位置，因此删除一个你完全不知道内容的元素毫无意义。如果要实现任意位置元素的删除操作，那么其他数据结构可能更合适（比如AVL树或者红黑树）。

当然这并不意味着不能删除二叉堆中的任意节点，参考algorithm - How to delete in a heap data structure? - Stack Overflow  删除堆中任意节点的一个最常见的应用是：heap representation of a priority queue of scheduled jobs, and somebody cancels one of the jobs.

本文既考虑堆顶元素的删除也考虑任意元素的删除。其实，删除堆顶元素是删除任意元素的特例，且删除堆顶元素的复杂度是删除任意元素在最坏情况下的复杂度O(logn)

2-1. 删除堆顶元素

假设从最大堆[90,85,70,60,80,30,20,10,50,40]中删除堆顶元素90，需要执行的步骤如下：

从[90,85,70,60,80,30,20,10,50,40]删除90之后，最大堆变成了[85,80,70,60,40,30,20,10,50]。
如上图所示，当从最大堆中删除堆顶元素时：先删除该数据，然后用最大堆中最后一个的元素插入这个空位；接着，把这个元素尽量往下挪，直到剩余的数据变成一个最大堆。往下挪的过程是需要找到该元素两个子节点中较大的子节点替换该元素。

2-2. 删除堆中任意元素

参考http://www.mathcs.emory.edu/~cheung/Courses/171/Syllabus/9-BinTree/heap-delete.html

删除堆中任意元素的伪码如下：

1, Delete a node from the array 
找到该元素并删除该元素对应的节点
(this creates a "hole" and the tree is no longer "complete")

2. Replace the deletion node with the "fartest right node" on the lowest level of the Binary Tree
将数组末尾元素挪至第1步删除的节点位置上
(This step makes the tree into a "complete binary tree")

3. Heapify (fix the heap):
if (value in replacement node < its parent node )
    Filter the replacement node UP the binary tree
else if (value in replacement node > its child node
    Filter the replacement node DOWN the binary tree
else
    nothing to do
调整数组元素使其重新成为一个最小堆：
若被替换位置上的元素<父节点元素(如果存在)
    将该元素与父节点元素交换，相当于把该元素往上挪
否则 若被替换位置上的元素>子节点元素(如果存在)
    将该元素与大于其的子节点元素中的较小值交换机，相当于把该元素往下挪
否则
    不需要做任何事情，该数组可以构成最小堆

假设有下面的最小堆：

当我们删除元素5时：

  • 删除元素5之后，红心的地方空出来了，此时，数组不再构成最小堆：

我们将数组末尾的元素21上挪到元素5原来的位置：

  • 此时，数组变成了完全二叉树，但仍然不满足最小堆的大小关系：

  • 我们必须调整数组元素的位置使其满足最小堆的条件。根据被替换节点也就是说21所在的节点与其父节点以及子节点的大小关系，可以将21这个元素上挪或者下移。由于21比它的父节点1小，比它的两个子节点9和11都要大，因此我们将21往下挪，将它与较小的子节点9交换：

  • 重复上述过程，继续判断21与它的子节点的大小关系。由于21比子节点17大，因此，21应该要往下挪，与它唯一的子节点交换位置：

  • 此时，21这个节点比父节点17大，同时它不存在子节点。此时的数组构成了最小堆。

下面是另一个删除堆中任意节点的例子：我们删除33这个元素对应的节点：

将33这个元素对应的节点与数组末尾元素19交换：

由于此时19比它的父节点小，且它没有子节点，因此我们交换19与它的父节点22（图中标错了）的位置：

19比它的父节点1小，同时比它的两个子节点也要小，数组构成最小堆

可以发现，删除堆中任意一个节点并将其上挪或者下移的次数最多为二叉堆的高度，当被删除的节点为根节点时，需要挪动的次数最多，为logn次，此时，删除操作的复杂度最高，为O(logn)
比如，当我们删除根节点1时：

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;

void constructMaxHeap(vector<int>&);
void constructMinHeap(vector<int>&);
void insertEleMaxHeap(int, vector<int>&);
void deleteEleMaxHeap(int, vector<int>&);
void insertEleMinHeap(int, vector<int>&);
void deleteEleMinHeap(int, vector<int>&);
void swap(vector<int>&, unsigned, unsigned);
void shiftDownMaxHeap(vector<int>&, int);
void shiftUpMaxHeap(vector<int>&, int);
void shiftDownMinHeap(vector<int>&, int);
void shiftUpMinHeap(vector<int>&, int);

int main() {
	int num=0;
	vector<int> maxHeap;
	cout << "Construct the max heap using the number entered: ";
	while(cin>>num) {
		maxHeap.push_back(num);
		if(getchar()=='\n') {
			break;
		}
	}
	constructMaxHeap(maxHeap);
	for(auto i:maxHeap) {
		cout << i << " ";
	}
	cout << endl;

	cout << "please enter the number u want to insert: ";
	int insertNum=0;
	cin >> insertNum;
	insertEleMaxHeap(insertNum, maxHeap);
	for(auto i:maxHeap) {
		cout << i << " ";
	}
	cout << endl;

	cout << "please enter the number u want to delete: ";
	int deleteNum=0;
	cin >> deleteNum;
	deleteEleMaxHeap(deleteNum, maxHeap);
	for(auto i:maxHeap) {
		cout << i << " ";
	}
	cout << endl << endl;

	vector<int> minHeap;
	cout << "Construct the min heap using the number entered: ";
	while(cin>>num) {
		minHeap.push_back(num);
		if(getchar()=='\n') {
			break;
		}
	}
	constructMinHeap(minHeap);
	for(auto i:minHeap) {
		cout << i << " ";
	}
	cout << endl;

	cout << "please enter the number u want to insert: ";
	cin >> insertNum;
	insertEleMinHeap(insertNum, minHeap);
	for(auto i:minHeap) {
		cout << i << " ";
	}
	cout << endl;

	cout << "please enter the number u want to delete: ";
	cin >> deleteNum;
	deleteEleMinHeap(deleteNum, minHeap);
	for(auto i:minHeap) {
		cout << i << " ";
	}
	cout << endl;
}

void constructMaxHeap(vector<int> &v) {
	for(int i=1; i<static_cast<int>(v.size()); ++i) {
		shiftUpMaxHeap(v, i);
	}
}

void constructMinHeap(vector<int> &v) {
	for(int i=1; i<static_cast<int>(v.size()); ++i) {
		shiftUpMinHeap(v, i);
	}
}

void swap(vector<int> &v, unsigned i, unsigned j) {
	int t=v[i];
	v[i]=v[j];
	v[j]=t;
}

void insertEleMaxHeap(int ele, vector<int> &v) {
	v.push_back(ele);
	shiftUpMaxHeap(v, v.size()-1);
}

void deleteEleMaxHeap(int ele, vector<int> &v) {
	unsigned deletePos=0;
	for(; deletePos<v.size(); ++deletePos) {
		if(ele==v[deletePos]) {
			break;
		}
	}
	swap(v, deletePos, v.size()-1);
	v.erase(v.end()-1);

	// 没有父节点也没有子节点，堆中只有一个元素
	if(v.size()==1) {
		return ;
	}
	// 没有父节点但有子节点，往下调整
	else if(deletePos==0) {
		shiftDownMaxHeap(v, deletePos);
	}
	// 有父节点但没有子节点，往上调整
	else if(2*deletePos+1>=v.size()) {
		shiftUpMaxHeap(v, deletePos);
	}
	// 既有子节点又有父节点，根据大小关系判断down()或者up()
	else {
		if(v[floor((deletePos-1)/2.0)]<v[deletePos]) {
			shiftUpMaxHeap(v, deletePos);
		}
		else if(v[2*deletePos+1]>v[deletePos]||
				2*deletePos+2<v.size()&&v[2*deletePos+2]>v[deletePos]) {
			shiftDownMaxHeap(v, deletePos);
		}
	}
}

void shiftDownMaxHeap(vector<int> &v, int p) {
	unsigned leftChildPos=2*p+1, rightChildPos=2*p+2;
	unsigned maxPos=p;
	while(p<v.size()) {
		if(leftChildPos<v.size() && v[leftChildPos]>v[maxPos]) {
			maxPos=leftChildPos;
		}
		if(rightChildPos<v.size() && v[rightChildPos]>v[maxPos]) {
			maxPos=rightChildPos;
		}
		if(p!=maxPos) {
			swap(v, p, maxPos);
			p=maxPos;
			leftChildPos=2*p+1;
			rightChildPos=2*p+2;
		}
		else {
			break;
		}
	}
}

void shiftUpMaxHeap(vector<int> &v, int p) {
	int parentPos=floor((p-1)/2.0);
	while(parentPos>=0 && v[parentPos]<v[p]) {
		swap(v, parentPos, p);
		p=parentPos;
		parentPos=floor((p-1)/2.0);
	}
}

void insertEleMinHeap(int ele, vector<int> &v) {
	v.push_back(ele);
	shiftUpMinHeap(v, v.size()-1);
}

void deleteEleMinHeap(int ele, vector<int> &v) {
	unsigned deletePos=0;
	for(unsigned i=0; i<v.size(); ++i) {
		if(ele==v[i]) {
			deletePos=i;
			break;
		}
	}
	swap(v, deletePos, v.size()-1);
	v.erase(v.end()-1);

	if(v.size()==1) {
		return;
	}
	else if(deletePos==0) {
		shiftDownMinHeap(v, deletePos);
	}
	else if(2*deletePos+1>=v.size()) {
		shiftUpMinHeap(v, deletePos);
	}
	else {
		if(v[floor((deletePos-1)/2.0)]>v[deletePos]) {
			shiftUpMinHeap(v, deletePos);
		}
		else if((v[deletePos*2+1]<v[deletePos])||
				(deletePos*2+2<v.size()&&v[deletePos*2+2]<v[deletePos])) {
			shiftDownMinHeap(v, deletePos);
		}
	}
}

void shiftDownMinHeap(vector<int> &v, int p) {
	unsigned leftChild=2*p+1, rightChild=2*p+2;
	unsigned minPos=p;
	while(p<v.size()) {
		if(leftChild<v.size()&&v[leftChild]<v[minPos]) {
			minPos=leftChild;
		}
		if(rightChild<v.size()&&v[rightChild]<v[minPos]) {
			minPos=rightChild;
		}
		if(minPos!=p) {
			swap(v, minPos, p);
			p=minPos;
			leftChild=2*p+1;
			rightChild=2*p+2;
		}
		else {
			break;
		}
	}
}

void shiftUpMinHeap(vector<int> &v, int p) {
	int parentPos=floor((p-1)/2.0);
	while(parentPos>=0 && v[parentPos]>v[p]) {
		swap(v, parentPos, p);
		p=parentPos;
		parentPos=floor((p-1)/2.0);
	}
}

二叉堆的插入、删除以及构造时间复杂度分析（最大堆为例）

二叉堆的插入

最好情况下，需要插入的节点只需要一次比较，比它的父节点小即可。因此时间复杂度为O(1)

最差情况下，需要插入的节点要一直从倒数第二层比较到第一层的根节点，共比较(h-1)次，h为高度。由于高为h的完全二叉树的节点数最多为2^h-1，所以有h=log(n+1)，n为节点数。故最差情况下插入的时间复杂度为O(logn)

平均情况下，需要插入的节点最终位于二叉堆的各个位置的概率均为1/(2^h-1)，而第i层的节点个数为2^(i-1)，如果该插入的节点最终位于第i层，则完成该插入操作需要比较(i-1)次。所以平均情况下的比较操作共：

故平均情况下，插入的时间复杂度为

求解得：

因此平均情况下插入的复杂度为O(1)

二叉堆的删除

最好情况下，二叉堆的删除只需要直接将被删除节点与数组最后的节点交换一次，并和子节点比较一次即可，复杂度为O(1)

最坏情况下，二叉堆的删除在交换后，需要将替换的节点与他的两个子节点进行比较，比较次数最多为(h-1)次，复杂度为O(logn)

二叉堆的构造

二叉堆的构造方法有两种，分别采用的是插入和删除的思想。

采用二叉堆插入思想进行二叉堆构造

可以想象刚开始是一个空堆，不停地将将元素插入这个堆。总共n个元素，每次插入时间复杂度为O(logn)，因此总的复杂度为O(nlogn)。

/* Apply insertion to construct heap.
 * Complexity is O(nlogn).
 */
void constructMaxHeap(const vector<int>& nums, vector<int>& heap) {
	for(const auto i:nums) {
		heap.push_back(i);
		int insertPos=heap.size()-1, parentPos=(insertPos-1)/2;
		while(parentPos>=0 && heap[parentPos]<heap[insertPos]) {
			swap(heap, parentPos, insertPos);
			insertPos=parentPos;
			parentPos=(insertPos-1)/2;
		}
	}
}

void constructMinHeap(const vector<int>& nums, vector<int>& heap) {
	for(auto num:nums) {
		heap.push_back(num);
		int insertPos=heap.size()-1, parentPos=(insertPos-1)/2;
		while(parentPos>=0 && heap[parentPos]>heap[insertPos]) {
			swap(heap, parentPos, insertPos);
			insertPos=parentPos;
			parentPos=(insertPos-1)/2;
		}
	}
}

采用二叉堆删除的思想构造二叉堆

可以直接将输入的数组看成一个二叉堆，只不过这个二叉堆现在不是最大堆，我们需要对它进行调整。调整直接从倒数第二层靠右边第一个有孩子的节点开始（倒数第一层都是叶子节点，不需要调整）一直到根节点止。调整的过程就是不断将待调整的节点与它的孩子比较，直到该节点的值比它的孩子都大或者该节点成为叶子节点。当需要调整的节点位于第i层，则该层共有2^(i-1)个节点，每次调整需要比较(h-i)次，因此总共的比较次数为

T(h)=\sum_{i=1}^{h-1}(h-i)*2^{i-1}

以比较次数作为基本操作，T(h)即为构造二叉堆的时间复杂度。展开可得：

T(h)=2^0(h-1)+2^1(h-2)+2^2(h-3)+...+2^{h-3}(h-h+2)+2^{h-2}(h-h+1)

T(h)=2^0(h-1)+2^1(h-2)+2^2(h-3)+...+2^{h-3}*2+2^{h-2}*1

2T(h)=2^1(h-1)+2^2(h-2)+2^3(h-3)+...+2^{h-2}*2+2^{h-1}*1

\therefore 2T(h)-T(h)=2^1(h-1-h+2)+2^2(h-2-h+3)+2^3(h-3-h+4)+...+2^{h-2}+2^{h-1}-2^0(h-1)

\therefore T(h)=2^1+2^2+...+2^{h-1}-2^0(h-1)=2^h-h-1

而二叉堆中总节点数n=2^h-1,因此构造二叉堆的时间复杂度为O(n)

void constructMaxHeap(vector<int> &num) {
	int pos=(num.size()-1)/2;
	for(; pos>=0; --pos) {
		maxifyHeap(num, pos);
	}
}

void maxifyHeap(vector<int> &num, int pos) {
	int maxPos=pos, leftChildPos=2*pos+1, rightChildPos=leftChildPos+1;
	while(pos<num.size()) {
		if(leftChildPos<num.size() && num[leftChildPos]>num[maxPos]) {
			maxPos=leftChildPos;
		}
		if(rightChildPos<num.size() && num[rightChildPos]>num[maxPos]) {
			maxPos=rightChildPos;
		}
		if(maxPos!=pos) {
			swap(num, maxPos, pos);
			pos=maxPos;
			leftChildPos=2*pos+1;
			rightChildPos=leftChildPos+1;
		}
		else {
			break;
		}
	}
}

void constructMinHeap(vector<int> &num) {
	int pos=(num.size()-2)/2;
	for(; pos>=0; --pos) {
		minifyHeap(num, pos);
	}
}

void minifyHeap(vector<int> &num, int pos) {
	int minPos=pos, leftChildPos=2*pos+1, rightChildPos=2*pos+2;
	while(pos<num.size()) {
		minPos=pos;
		if(leftChildPos<num.size() && num[leftChildPos]<num[minPos]) {
			minPos=leftChildPos;
		}
		if(rightChildPos<num.size() && num[rightChildPos]<num[minPos]) {
			minPos=rightChildPos;
		}
		if(minPos!=pos) {
			swap(num, pos, minPos);
			pos=minPos;
			leftChildPos=2*pos+1;
			rightChildPos=leftChildPos+1;
		}
		else {
			break;
		}
	}
}

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

_silverBlack
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构--大小堆
CodingStart
08-05 3603
最大堆，最小堆创建过程 以及 一些基本操作
堆和堆排序
lwj的博客
12-03 382
堆排序是原地排序、时间复杂度O(nlogn)、不稳定 1.性质： 堆是一个完全二叉树 任何节点的值都大于等于（或小于等于）子树节点的值 2.特点 每个节点的值都大于等于（或小于等于）其子树节点的值。因此，堆被分成了两类，大顶堆和小顶堆。 3.大顶堆的操作 1.插入一个元素 把新插入的数据放到数组的最后，从下往上的堆化方法，让新插入的节点与父节点对比大小。如果不满足子节点小于等于父节点的大小关系...
深入理解C++中的堆：从基本概念到实际应用
最新发布
Lion_Long的博客
05-13 1176
堆是一种具有树形结构的数据结构，它遵循堆属性，即：每个节点必须小于其每个子节点。“堆”这个名字可能来自于这样一个事实：如果堆放一堆东西并希望它能保持平衡，人类更愿意把大的东西放在底部，小的东西放在顶部：请注意，这与包含动态分配对象的内存区域中的堆完全无关（与栈相对，栈也是一种数据结构的名称）。堆的一个最重要的特性是，其最小元素位于其根部，易于访问。在堆中，每个节点理论上可以有任意数量的子节点。但在STL中，堆的节点有两个子节点，因此在本文中将用堆来指代二叉堆。
什么是大顶堆？举个例子
weixin_45791946的博客
03-14 457
大顶堆通常用于实现优先队列等数据结构，其中需要快速访问和删除最大元素。它的实现通常是通过数组来完成的，其中父节点和子节点的关系可以用数组的索引来表示。在大顶堆中，如果一个节点的索引是i，那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。
算法自学__小根堆(Heap)
MaTF_的博客
01-19 2566
参考资料: https://www.cnblogs.com/WindSun/p/11444446.html https://www.cnblogs.com/huashanqingzhu/p/11040390.html 小根堆的性质 小根堆是一颗完全二叉树 父节点的值小于或等于子节点的值 小根堆的存储 由于小根堆是一颗完全二叉树, 所以一般用一维数组来实现堆. 映射关系: 对于一个树中的结点, 假设其在数组中的下标为i 其父结点的下标为(i-1)/2 其左子结点的下标为2i+1, 其右子结点
Heap(堆)的C++实现
qq_38844835的博客
07-10 816
Heap的实现
C++直接插入排序详解以及代码实现
12-25
直接插入排序的时间复杂度分析如下： - 最好情况：如果输入数组已经是有序的，那么直接插入排序只需要进行n-1次比较，因此时间复杂度为O(n)。 - 最坏情况：当输入数组完全逆序时，每个元素都需要与其他所有元素进行...
C++实现基数排序的方法详解
09-05
基数排序是一种非比较型整数排序算法，它不依赖元素之间的相对大小关系，而是通过将数字按位划分并逐位进行排序来实现整体的有序排列。C++中实现基数排序通常涉及以下步骤： 1. **位数处理**： - 首先，确保所有待...
详解Bucket Sort桶排序算法及C++代码实现示例
09-02
- 优点：在数据分布均匀的情况下，桶排序可以实现线性时间复杂度，效率较高。 - 缺点：依赖于数据分布，如果数据分布不均匀，性能可能会急剧下降。此外，需要额外的存储空间来创建桶。 桶排序是一种实用的排序...
C++ min/max_element 函数用法详解
08-25
复杂度分析： min_element 和 max_element 函数的时间复杂度都是 O(n)，其中 n 是序列的长度。因此，这两个函数适合用于处理大规模数据。 C++ 中的 min_element 和 max_element 函数是非常有用的，它们可以帮助...
C++插入排序算法实例详解
08-28
C++插入排序算法实例详解是指使用C++语言实现的插入排序算法，主要用于对数组或链表进行排序。该算法的主要思想是每次将一个待排序的元素，按其大小插入到已经排好序的子序列的适当位置，知道全部元素插入完成为止。...
自己写的heap，C++实现
09-23
2010年9月23日 by pafone //自己写的一个二叉堆 //底层用vector 实现 实现的是小堆 2010年9月23日完成，经过初步的测试验证正确，没有对比过STL验证
堆树（最大堆、最小堆）详解
热门推荐
渴望，就奋力追寻...
03-16 6万+
一、堆树的定义 堆树的定义如下： （1）堆树是一颗完全二叉树； （2）堆树中某个节点的值总是不大于或不小于其孩子节点的值； （3）堆树中每个节点的子树都是堆树。 当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。如下图所示，左边为最大堆，右边为最小堆。 二、堆树的操作 以最大堆为例进行讲解
大小堆的实现，删除，添加
tp93125334的博客
07-31 1069
大小堆的实现   删除   添加 最小堆：任一结点的关键码均小于等于它的左右孩子的关键码，位于堆顶结点的关键码最小  最大堆：任一结点的关键码均大于等于它的左右孩子的关键码，位于堆顶结点的关键码 最大 先建堆：利用二叉树建小堆方法 先找到第一个非叶子节点，然后检查它是否有左右叶子（都有选其小的），再和节点比较，若小于该节点，则交换这两个元素；接着把这个节点当作叶子，
C++ STL（第十篇：heap）
weixin_39640298的博客
04-11 4662
1、heap的概述 heap（堆）并不归属于 STL 容器组件，它是个幕后英雄，扮演 priority queue（优先队列）的助手。priority queue 允许用户以任何次序将任何元素推入容器，但取出时一定是从优先权最高的元素开始取。而 binary max heap（最大二叉堆）具有这样的特性，适合作为 priority queue 的底层机制。 因为后面要整理 priority que...
数据结构（C++） —— 最小堆（mainHeap）
Anna的博客
02-19 1896
一、理论知识普及： 假定在各个数据记录（元素）中存在一个能够标识数据记录（元素）的数据项，并将依据该数据项对数据进行组织，这个数据项就成为关键码（KEY）。 如果有一个关键码的集合，把它的所有元素按完全二叉树的顺序存储方式存放在一个一维数组中，并满足无论在哪棵树上看，父节点的值总比子节点的小，称这个集合为最小堆。 二、性质： 由于对存储在下标从0开始计数的数组中，因此，在堆中给定下标为i的
C++标准库中的堆-heap
flyyufenfei的博客
10-08 1万+
转载：https://elloop.github.io/c++/2016-11-29/learning-using-stl-72-make-heap 前言 本文介绍如何使用STL里的heap（堆）算法。第一次接触heap这种数据结构是在大学的数据结构教材上，它是一棵完全二叉树。在STL中，heap是算法的形式提供给我们使用的。包括下面几个函数： make_heap: 根据指定的迭
C语言实现最小堆minheap(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-24 1196
C语言实现最小堆minheapmin_heap结构体实现以下8个接口最小堆minheap完整源码（定义，实现，main函数测试） min_heap结构体 typedef struct min_heap { int *p; int size; int count; } Heap; 实现以下8个接口 Heap *create_heap(Heap *heap); /*Creates a min_heap structure and returns a
C++ priority_queue 最大堆、最小堆
二十三小时
05-14 3万+
问题描述通常在刷题的时候，会遇到最大堆、最小堆的问题，这个时候如果自己去实现一个也是OK的，但是通常时间不太够，那么如何处理？这时，就可以借助C++ STL的priority_queue。具体分析 需要注意的是，C++ STL默认的priority_queue是将优先级最大的放在队列最前面，也即是最大堆。那么如何实现最小堆呢？ 假设有如下一个struct：struct Node { int

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值