大小堆详解&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
    评论
专栏目录
【数据结构】大小堆的理解，创建，增加和删除元素操作
qq_39487033的博客
10-21 1532
什么是大小堆？ 大小堆是基于完全二叉树的结构； 大堆：任意一个结点的左右孩子的数据都小于此结点的数据，位于堆顶的结点的数据最大。 小堆：任意一个结点的左右孩子的数据都大于此结点的数据，位于堆顶的结点的数据最小。 下面以小堆为例，图解： 以下都是以小堆为例 如何创建小堆？ 首先我们只会得到一个数组，并且我们知道堆最终形态是完全二叉树。通过递归的思想，如果能把最后一个以非叶子结点为根的树变为小堆，然...
C++ 实现堆（heap）
m0_45864023的博客
03-06 710
#include<iostream> #include<cstdlib> #include<cstring> using namespace std; class minHeap{ private: int *heap; //存储数据和key值的数组，为了简单在这人只存储整数key值 int capacity; // 数组的的最大容量 int size; // 目前为止数组中有数据的
数据结构--大小堆
CodingStart
08-05 3603
最大堆，最小堆创建过程 以及 一些基本操作
深入理解C++中的堆：从基本概念到实际应用
最新发布
Lion_Long的博客
05-13 1164
堆是一种具有树形结构的数据结构，它遵循堆属性，即：每个节点必须小于其每个子节点。“堆”这个名字可能来自于这样一个事实：如果堆放一堆东西并希望它能保持平衡，人类更愿意把大的东西放在底部，小的东西放在顶部：请注意，这与包含动态分配对象的内存区域中的堆完全无关（与栈相对，栈也是一种数据结构的名称）。堆的一个最重要的特性是，其最小元素位于其根部，易于访问。在堆中，每个节点理论上可以有任意数量的子节点。但在STL中，堆的节点有两个子节点，因此在本文中将用堆来指代二叉堆。
数据结构：大顶堆、小顶堆
crr411422的博客
04-04 7571
堆是其中一种非常重要且实用的数据结构。堆可以用于实现优先队列，进行堆排序，以及解决各种与查找和排序相关的问题。大顶堆和小顶堆都是堆数据结构的变种，它们分别能够在 O(1) 时间内访问最大和最小元素。无论是大顶堆还是小顶堆，插入元素和删除堆顶元素的时间复杂度都是 O(log n)，其中 n 为堆中的元素数量。
大小堆&&堆排序&&堆的应用
IT_iverson的博客
01-09 1070
一.首先说一下堆的概念吧这里就不按照标准的概念来说了，就说说我理解的堆。 堆就是一个数组中的元素，参考着完全二叉树的这种数据结构存储在数组中，这样就是一个堆。注意：这里是参考，实际的存储还是在数组中，只不过数组中的存储顺序满足完全二叉树而已。说到堆离不开大小堆，下面继续介绍大小堆的概念。 1.最小堆：因为数组中的元素是参考完全二叉树的存储顺序存储的，所以小堆就是每一个双亲结点的值都
堆——神奇的优先队列 大根堆小根堆详解，附小根堆C++代码实现与STL相关
哇咔咔的博客
04-03 6159
文章目录前置知识堆操作小根堆插入代码实现小根堆删除代码实现测试代码STL实现——priority_queue1.使用2.创建3.成员函数 前置知识 堆是一个完全二叉树（最后一层可以不满，上面的每一层都是满的。一个结点若只有一个孩子结点，那一定是它的左孩子。如下图）这是一个逻辑上基于完全二叉树、物理上一般基于线性数据结构（如数组、向量、链表等）的一种数据结构。 完全二叉树最重要的性质：如果n个节点的完全二叉树的节点按照层次并按从左到右的顺序从0开始编号，对于人一个绩点都有： 序号为0的节点是根 对
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++语言实现的插入排序算法，主要用于对数组或链表进行排序。该算法的主要思想是每次将一个待排序的元素，按其大小插入到已经排好序的子序列的适当位置，知道全部元素插入完成为止。...
堆和堆排序
lwj的博客
12-03 381
堆排序是原地排序、时间复杂度O(nlogn)、不稳定 1.性质： 堆是一个完全二叉树 任何节点的值都大于等于（或小于等于）子树节点的值 2.特点 每个节点的值都大于等于（或小于等于）其子树节点的值。因此，堆被分成了两类，大顶堆和小顶堆。 3.大顶堆的操作 1.插入一个元素 把新插入的数据放到数组的最后，从下往上的堆化方法，让新插入的节点与父节点对比大小。如果不满足子节点小于等于父节点的大小关系...
算法-堆排序
Java开发者Peng博客
11-03 315
1、堆排序是一种原地的、时间复杂度为 O(nlogn) 的排序算法。 2、了解堆排序，先看下什么是堆（只要满足这两点，它就是一个堆）： 2.1：堆必须是一个完全二叉树。完全二叉树要求，除了最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列。 2.2：对于每个节点的值都大于等于子树中每个节点值的堆，我们叫做“大顶堆”。对于每个节点的值都小于等于子树中每个节点值的堆，我们叫做“小顶堆”。 其中第 1 个和第 2 个是大顶堆，第 3 个是小顶堆，第 4 个不是堆。 ...
排序：堆排序算法分析以及插入删除操作
jungleirim的博客
09-28 985
若n个关键字序列L1...nL[ 1...n]L1...n满足下面某一条性质，则称为堆若满足∶Li≥L2i且Li≥L2i11≤i≤n2L(i)≥L(2i)且L(i)≥L(2i+1) (1 ≤i ≤n/2 )Li≥L2i且Li≥L2i11≤i≤n/2大根堆(大顶堆)Li≤L2i且Li≤L2i11≤i≤n2。
C++ 堆、大顶堆、小顶堆、堆排序
琅嬛福地
11-11 4964
堆(heaps)不是容器，而是一种特别的数据组织方式。};};int id;} };} };return 0;
什么是大顶堆？举个例子
weixin_45791946的博客
03-14 456
大顶堆通常用于实现优先队列等数据结构，其中需要快速访问和删除最大元素。它的实现通常是通过数组来完成的，其中父节点和子节点的关系可以用数组的索引来表示。在大顶堆中，如果一个节点的索引是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, 其右子结点
堆的实现（大小堆及 优先队列)
weixin_33970449的博客
04-27 325
一、堆的概念 堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构。 堆结构的二叉树存储是： 最大堆：每个父节点的都大于孩子节点。 最小堆：每个父节点的都小于孩子节点。 堆栈中的物体具有一个特性： 最后一个放入堆栈中的物体总是被最先拿出来， 这个特性通常称为后进先出(LIFO)队列。 堆栈中定义了一些操作。 两个最重要的是PUSH和POP。 PUSH操...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值