数据结构之堆——C++实现大顶堆和小顶堆

最新推荐文章于 2024-05-13 09:00:00 发布
最新推荐文章于 2024-05-13 09:00:00 发布
阅读量5.6k 收藏 27
点赞数 8
分类专栏： 数据结构 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43744293/article/details/118544078
版权

大小顶堆的实现

什么是大顶堆和小顶堆

堆是一种完全二叉树。完全二叉树的定义：所有节点从上往下，从左往右的依次排列，不能有空位置，是为完全二叉树。下面是完全二叉树和不完全二叉树的示意图：

在这里插入图片描述
大顶堆定义：父节点都大于左右子节点。
小顶堆定于：父节点都小于左右子节点。
二者示意图如下：
在这里插入图片描述

大小顶堆的底层实现

一般来说，定义二叉树都是定义一个节点类，节点类中包含本节点的数据元素和两个节点指针，分别指向左右子节点，通过这两个节点指针将整个树节点连起来。如下：

template <typename Type>
class BstNode
{
public:
	BstNode():leftChild(nullptr), rightChild(nullptr){};
	BstNode(Type _content) :leftChild(nullptr), rightChild(nullptr)
	{
		content = _content;
	};
private:
	Type content;
	BstNode<Type> *leftChild;
	BstNode<Type> *rightChild;
};

实际上，堆一般用数组表示，如下图。究其原因，我认为的是通过节点类的方式占用的内存空间多，多加了两个指针。并且当我们做插入操作向上渗透时，需要找到节点的父节点(文章后面会详细描述)，这样实际的节点应该再加一个标识父节点的指针。这样实际是多了3个指针。（Ps：当然，我的水平也有限，只能看到这一层，如果不对的话或者还有其他原因，欢迎批评指正。）
在这里插入图片描述

代码实现小顶堆

定义小顶堆类

template<typename T>
class MinHeap
{
public:
	MinHeap(int _maxsize = 10);
	~MinHeap();

	void Push(T _data);//插入数据
	void Pop();//删除堆顶数据
	T& Top();//获取堆顶数据

	void ShowHeap();//打印堆
private:
	T *heap;
	int MaxSize;//堆数组的最大大小
	int currentSize;//堆数组当前大小
};

构造函数

template<typename T>
MinHeap<T>::MinHeap(int _maxsize)
:MaxSize(_maxsize)
{
	try{
		if (MaxSize < 1)
			throw "Error Size,< 1";
		heap = new T[MaxSize];
		currentSize = 0;
	}
	catch (const char* cp){

		//1.提示用户错误信息，提示用户重新输入
		int size = 0;
		while (size < 1){
			std::cout << cp << std::endl;
			std::cout << "please Enter size again" << std::endl;
			std::cin >> size;
		}

		//2.初始化MinHeap类的数据成员
		MaxSize = size;
		heap = new T[MaxSize];
		currentSize = 0;
	}
}

解释：这里我做了异常处理。当堆数组的大小MaxSize<1时，抛出异常，并提示输入大小，一直到输入的大小>=1。
关于C++的异常处理，参考：详解C++异常处理使用方法。

插入

插入方法：

  1. 首先将需插入的数据放在堆的最后一个位置
  2. 然后依次和父节点比较，比父节点小就和父节点交换，再向上比较；比父节点大就停止比较。

比如我按20->30->15->10->9->8->12依次插入，插入示意图如下：
在这里插入图片描述

代码如下：

template<typename T>
void MinHeap<T>::Push(T _data)
{
	if (currentSize == MaxSize){
		//堆满了，扩容
	}
	//将数据放入最后一个位置
	//注意：currentSize和数组索引值差1：
	//比如currentSize = 3，对应的数组索引为2
	//所以，当currentSize=3时，即堆数组有3个数据时，新插入的数据应在数组索引3上
	heap[currentSize] = _data;

	int sonIndex = currentSize;//最后一个位置的数组索引
	int fatherIndex = (currentSize - 1)/ 2;//最后一个位置的父节点的数组索引

	while (sonIndex > 0){
		if (heap[sonIndex] < heap[fatherIndex]){
			std::swap(heap[sonIndex], heap[fatherIndex]);//交换父子节点元素
			
			//继续向上
			sonIndex = fatherIndex;
			fatherIndex = (fatherIndex - 1) / 2;
		}
		else break;
	}

	currentSize++;//堆数组当前大小加1
}

这里简单解释一下：

  1. currentSize表示的是当前堆数组有多少个元素。如下图，比如currentSize = 3，表明当前有3个数据。再push一个数据时，在数组的存储的位置刚好是索引3。
  2. 如下图，节点7和节点4的父节点都是节点2。节点7的索引为1，节点4索引为2，节点2的索引为0，所以计算7 4 节点的父节点公式为==（索引-1）/2==，其他节点也一样。这里你不从数组索引角度，从树的层序角度也是一样，只不过公式要变为：层序号/2。
    在这里插入图片描述

扩大堆数组容量

在上述代码中，当currentSize == MaxSize时，表示堆数组已经满了，此时我们需要扩大数组的大小，这和循环队列和顺序栈是一样的原理。
循环队列：带你一步步用C++实现循环队列
顺序栈：用C++实现顺序栈(以数组为底层数据结构，可自动扩容)
代码如下：

template<typename T>
void MinHeap<T>::ChangeSize()
{
	int size = MaxSize * 2;//堆数组容量扩大1倍

	T* tmp = new T[size];//1.申请一块原来2倍大小的空间。
	std::copy(heap, heap + MaxSize, tmp);//2.将栈中的数据赋值到新的内存空间
	delete[] heap;//3.删除老的空间

	heap = tmp;//4.heap指向新地址
	MaxSize = size;//5.改变MaxSize
}

注意：由于C++编译器是不检查数组越界的，所以，即使程序员不自己扩容，使用越界的索引程序也不会报错，只是它会继续向下占用一块内存。程序员必须注意数组越界的问题。

std::copy()函数介绍：
使用std::copy时会报错，解决方法是：在预处理器加入(项目属性—-C/C++—-预处理—-预处理器定义)：_SCL_SECURE_NO_WARNINGS。

删除

删除方法：

  1. 首先把堆顶元素删除
  2. 接着把堆的最后一个数据放在堆顶
  3. 最后把堆顶数据向下渗透，不断的和两个子节点比较，若父节点不比两个子节点的任意一个小，取两个子节点中小的和父节点交换，一直这样下去，直到父节点比左右子节点都小。

删除示意图如下：
在这里插入图片描述

代码如下：

template<typename T>
void MinHeap<T>::Pop()
{
	if (currentSize == 0){
		std::cout << "Error!The heap is empty，Invalid operation." << std::endl;
		return;
	}

	heap[0] = heap[--currentSize];//删除堆顶，并将最后一个数据放在堆顶

	int fatherIndex = 0;//父节点索引为堆顶
	int leftSonIndex = fatherIndex * 2 + 1;//获得左子节点索引
	int RightSonIndex = leftSonIndex + 1;//获得右子节点索引

	//确认循环条件
	while (leftSonIndex < currentSize ){
		/**1.找左右子节点中最小值的数组索引***/
		int minIndex;
		//如果RightSonIndex < currentSize,表明fatherIndex有右子节点
		if (RightSonIndex < currentSize){
			minIndex = heap[leftSonIndex] > heap[RightSonIndex] ?  RightSonIndex: leftSonIndex;
		}
		else{
			minIndex = leftSonIndex;
		}

		/**2.父节点大就交换，否则退出循环***/
		if (heap[fatherIndex] > heap[minIndex])
			std::swap(heap[fatherIndex], heap[minIndex]);
		else break;

		fatherIndex = minIndex;
		leftSonIndex = fatherIndex * 2 + 1;
		RightSonIndex = leftSonIndex + 1;
	}
}

对于while循环条件说明：
使用左子节点leftSonIndex和currentSize比较，不要使用右子节点RightSonIndex，因为右子节点RightSonIndex可能没有。当然，你也可以使用父节点fatherIndex和currentSize比较：fatherIndex<currentSize/2。
验证循环的真确性，只需考虑以下三种情况，大家可自行验证。
在这里插入图片描述

析构函数

析构只需将申请的内存释放即可。

template<typename T>
MinHeap<T>::~MinHeap()
{
	delete []heap; 
}

代码实现大顶堆

原理和小顶堆一样，直接给出代码

#ifndef _MAX_HEAP_H
#define _MAX_HEAP_H

template<typename T>
class MaxHeap
{
public:
	MaxHeap(int _maxsize = 10);
	~MaxHeap();

	void Push(T _data);//插入数据
	void Pop();//删除堆顶数据
	T& Top();//获取堆顶数据

	void ShowHeap();
private:
	T *heap;
	int MaxSize;//堆数组的最大大小
	int currentSize;//堆数组当前大小

	void ChangeSize();//扩大堆数组的大小
};

template<typename T>
MaxHeap<T>::MaxHeap(int _maxsize)
:MaxSize(_maxsize)
{
	try{
		if (MaxSize < 1)
			throw "Error Size,< 1";
		heap = new T[MaxSize];
		currentSize = 0;
	}
	catch (const char* cp){

		//1.提示用户错误信息，提示用户重新输入
		int size = 0;
		while (size < 1){
			std::cout << cp << std::endl;
			std::cout << "please Enter size again" << std::endl;
			std::cin >> size;
		}

		//2.初始化MaxHeap类的数据成员
		MaxSize = size;
		heap = new T[MaxSize];
		currentSize = 0;
	}
}
template<typename T>
MaxHeap<T>::~MaxHeap()
{
	delete[]heap;
}
template<typename T>
void MaxHeap<T>::Push(T _data)
{
	if (currentSize == MaxSize){
		//堆满了，扩容
		ChangeSize();
	}
	//将数据放入最后一个位置
	//注意：currentSize和数组索引值差1：
	//比如currentSize = 3，对应的数组索引为2
	//所以，当currentSize=3时，即堆数组有3个数据时，新插入的数据应在数组索引3上
	heap[currentSize] = _data;

	int sonIndex = currentSize;//最后一个位置的数组索引
	int fatherIndex = (currentSize - 1) / 2;//最后一个位置的父节点的数组索引

	while (sonIndex > 0){
		if (heap[sonIndex] > heap[fatherIndex]){
			std::swap(heap[sonIndex], heap[fatherIndex]);

			//继续向上
			sonIndex = fatherIndex;
			fatherIndex = (fatherIndex - 1) / 2;
		}
		else break;
	}

	currentSize++;
}
template<typename T>
void MaxHeap<T>::Pop()
{
	if (currentSize == 0){
		std::cout << "Error!The heap is empty，Invalid operation." << std::endl;
		return;
	}

	heap[0] = heap[--currentSize];//删除堆顶，并将最后一个数据放在堆顶

	int fatherIndex = 0;//父节点索引为堆顶
	int leftSonIndex = fatherIndex * 2 + 1;//获得左子节点索引
	int RightSonIndex = leftSonIndex + 1;//获得右子节点索引

	//确认循环条件
	while (leftSonIndex < currentSize){
		/**1.找左右子节点中最小值的数组索引***/
		int maxIndex;
		//如果RightSonIndex < currentSize,表明fatherIndex有右子节点
		if (RightSonIndex < currentSize){
			maxIndex = heap[leftSonIndex] < heap[RightSonIndex] ? RightSonIndex : leftSonIndex;
		}
		else{
			maxIndex = leftSonIndex;
		}

		/**2.父节点小就交换，否则退出循环***/
		if (heap[fatherIndex] < heap[maxIndex])
			std::swap(heap[fatherIndex], heap[maxIndex]);
		else break;

		fatherIndex = maxIndex;
		leftSonIndex = fatherIndex * 2 + 1;
		RightSonIndex = leftSonIndex + 1;
	}
}
template<typename T>
T& MaxHeap<T>::Top()
{
	if (currentSize == 0)
		throw "Error.The heap is empty,there is not data.";
	return heap[0];
}

template<typename T>
void MaxHeap<T>::ChangeSize()
{
	int size = MaxSize * 2;//堆数组容量扩大1倍

	T* tmp = new T[size];//1.申请一块原来2倍大小的空间。
	std::copy(heap, heap + MaxSize, tmp);//2.将栈中的数据赋值到新的内存空间
	delete[] heap;//3.删除老的空间

	heap = tmp;//4.heap指向新地址
	MaxSize = size;//5.改变MaxSize
}

template<typename T>
void MaxHeap<T>::ShowHeap()
{
	int size = 1;
	for (int i = 0; i < currentSize;){
		std::cout << "[ ";
		for (int j = 0; j < size && i < currentSize; j++){
			std::cout << heap[i++] << " ";
		}
		std::cout << "]" << std::endl;
		size *= 2;
	}
}

#endif

测试

下面只测试小顶堆，大顶堆可自行测试。
MinHeap.h

#ifndef _MIN_HEAP_H
#define _MIN_HEAP_H

template<typename T>
class MinHeap
{
public:
	MinHeap(int _maxsize = 10);
	~MinHeap();

	void Push(T _data);//插入数据
	void Pop();//删除堆顶数据
	T& Top();//获取堆顶数据

	void ShowHeap();
private:
	T *heap;
	int MaxSize;//堆数组的最大大小
	int currentSize;//堆数组当前大小

	void ChangeSize();//扩大堆数组的大小
};

template<typename T>
MinHeap<T>::MinHeap(int _maxsize)
:MaxSize(_maxsize)
{
	try{
		if (MaxSize < 1)
			throw "Error Size,< 1";
		heap = new T[MaxSize];
		currentSize = 0;
	}
	catch (const char* cp){

		//1.提示用户错误信息，提示用户重新输入
		int size = 0;
		while (size < 1){
			std::cout << cp << std::endl;
			std::cout << "please Enter size again" << std::endl;
			std::cin >> size;
		}

		//2.初始化MinHeap类的数据成员
		MaxSize = size;
		heap = new T[MaxSize];
		currentSize = 0;
	}
} 
template<typename T>
MinHeap<T>::~MinHeap()
{
	delete []heap; 
}
template<typename T>
void MinHeap<T>::Push(T _data)
{
	if (currentSize == MaxSize){
		//堆满了，扩容
		ChangeSize();
	}
	//将数据放入最后一个位置
	//注意：currentSize和数组索引值差1：
	//比如currentSize = 3，对应的数组索引为2
	//所以，当currentSize=3时，即堆数组有3个数据时，新插入的数据应在数组索引3上
	heap[currentSize] = _data;

	int sonIndex = currentSize;//最后一个位置的数组索引
	int fatherIndex = (currentSize - 1)/ 2;//最后一个位置的父节点的数组索引
	 
	while (sonIndex > 0){
		if (heap[sonIndex] < heap[fatherIndex]){
			std::swap(heap[sonIndex], heap[fatherIndex]);
			
			//继续向上
			sonIndex = fatherIndex;
			fatherIndex = (fatherIndex - 1) / 2;
		}
		else break;
	}

	currentSize++;
}
template<typename T>
void MinHeap<T>::Pop()
{
	if (currentSize == 0){
		std::cout << "Error!The heap is empty，Invalid operation." << std::endl;
		return;
	}

	heap[0] = heap[--currentSize];//删除堆顶，并将最后一个数据放在堆顶

	int fatherIndex = 0;//父节点索引为堆顶
	int leftSonIndex = fatherIndex * 2 + 1;//获得左子节点索引
	int RightSonIndex = leftSonIndex + 1;//获得右子节点索引

	//确认循环条件
	while (leftSonIndex < currentSize ){
		/**1.找左右子节点中最小值的数组索引***/
		int minIndex;
		//如果RightSonIndex < currentSize,表明fatherIndex有右子节点
		if (RightSonIndex < currentSize){
			minIndex = heap[leftSonIndex] > heap[RightSonIndex] ?  RightSonIndex: leftSonIndex;
		}
		else{
			minIndex = leftSonIndex;
		}

		/**2.父节点大就交换，否则退出循环***/
		if (heap[fatherIndex] > heap[minIndex])
			std::swap(heap[fatherIndex], heap[minIndex]);
		else break;

		fatherIndex = minIndex;
		leftSonIndex = fatherIndex * 2 + 1;
		RightSonIndex = leftSonIndex + 1;
	}
}
template<typename T>
T& MinHeap<T>::Top()
{
		if (currentSize == 0)
			throw "Error.The heap is empty,there is not data.";
		return heap[0];
}

template<typename T>
void MinHeap<T>::ChangeSize()
{
	int size = MaxSize * 2;//堆数组容量扩大1倍

	T* tmp = new T[size];//1.申请一块原来2倍大小的空间。
	std::copy(heap, heap + MaxSize, tmp);//2.将栈中的数据赋值到新的内存空间
	delete[] heap;//3.删除老的空间

	heap = tmp;//4.heap指向新地址
	MaxSize = size;//5.改变MaxSize
}

template<typename T>
void MinHeap<T>::ShowHeap()
{
	int size = 1;
	for (int i = 0; i < currentSize;){
		std::cout << "[ ";
		for (int j = 0; j < size && i < currentSize; j++){
			std::cout <<heap[i++] <<" ";
		}
		std::cout << "]"<<std::endl;
		size *= 2;
	}
}

#endif

Main.cpp

#include <iostream>
#include "MinHeap.h"
#include "MaxHeap.h"

using namespace std;

int main()
{
	MinHeap<int> a(4);
	
	/*************插入***********/
	a.Push(20);

	a.ShowHeap();
	cout << endl;

	a.Push(30);

	a.ShowHeap(); 
	cout << endl;

	a.Push(15);

	a.ShowHeap();
	cout << endl;

	a.Push(10);

	a.ShowHeap();
	cout << endl;

	a.Push(9);

	a.ShowHeap();
	cout << endl;

	a.Push(8);

	a.ShowHeap();
	cout << endl;

	a.Push(12);

	a.ShowHeap();
	cout << endl;


	/*************删除***********/
	cout << "**********删除************" << endl;
	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;
	
	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	cout << a.Top() << endl;
	a.Pop();
	a.ShowHeap();
	cout << endl;

	a.Pop();

	system("pause");
	return 0;
}

结果:
在这里插入图片描述
上面就是C++实现的大小顶堆。

如果有疑问，欢迎评论区下方留言；本人水平有限 ，如有错误，也欢迎在评论区下方批评指正。若是喜欢本文，就帮忙点赞吧！

代码乌龟
关注
  • 8
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C/C++优先队列std::priority_queue实现大顶堆和小顶堆
UUUUTaossienUUUU的专栏
03-11 2542
C/C++优先队列std::priority_queue实现大顶堆和小顶堆
C++大顶堆和小顶堆
weixin_42749137的博客
11-24 8533
C++大顶堆和小顶堆原理大顶堆小顶堆大顶堆和小顶堆对比图大顶堆和小顶堆的实现代码 原理   堆数据结构是一种数组对象，它可以被视为一颗完全二叉树结构（或者也有可能是满二叉树） 大顶堆   根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，称为大顶堆。大根堆要求根节点的关键字既大于或等于左子树的关键字值，又大于或等于右子树的关键字值。 小顶堆   根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者，称为小顶堆。小根堆要求根节点的关键字既小于或等于左子树的关键字值，又小于或等于右子树的关键字值。
深入理解C++中的堆：从基本概念到实际应用
最新发布
Lion_Long的博客
05-13 1075
堆是一种具有树形结构的数据结构，它遵循堆属性，即：每个节点必须小于其每个子节点。“堆”这个名字可能来自于这样一个事实：如果堆放一堆东西并希望它能保持平衡，人类更愿意把大的东西放在底部，小的东西放在顶部：请注意，这与包含动态分配对象的内存区域中的堆完全无关（与栈相对，栈也是一种数据结构的名称）。堆的一个最重要的特性是，其最小元素位于其根部，易于访问。在堆中，每个节点理论上可以有任意数量的子节点。但在STL中，堆的节点有两个子节点，因此在本文中将用堆来指代二叉堆。
数据结构：大顶堆、小顶堆
crr411422的博客
04-04 7300
堆是其中一种非常重要且实用的数据结构。堆可以用于实现优先队列，进行堆排序，以及解决各种与查找和排序相关的问题。大顶堆和小顶堆都是堆数据结构的变种，它们分别能够在 O(1) 时间内访问最大和最小元素。无论是大顶堆还是小顶堆，插入元素和删除堆顶元素的时间复杂度都是 O(log n)，其中 n 为堆中的元素数量。
【数据结构】C++实现小顶堆
weixin_45781252的博客
08-25 604
C++实现小顶堆 //Myheap.h #pragma once #include<iostream> #include<vector> using namespace std; //小顶堆 class MyHeap { public: MyHeap();//构造函数 MyHeap(vector<int>); void insert(int); void pop(); int top(); void assgin(vector<int>);
C++最小堆和最大堆实现
weixin_54720578的博客
03-15 746
最大最小堆在c++中相关的函数是：它们包含在头文件中1）make_heap（建堆）在容器范围内，就地建堆，保证最大(小)值在所给范围的最前面，其他值的位置不确定。可以有两个参数，也可以有三个参数，前两个参数是指向开始元素的迭代器和指向结束元素的下一个元素的迭代器。第三个参数（谓词）是可选的，不选默认大顶堆。我们可以自定义比较函数来设定小顶堆2）pop_heap（取出）将堆顶(所给范围的最前面)元素移动到所给范围的最后，并且将新的最大(小)值置于所给范围的最前面。
C++STL算法之堆算法
m0_74228185的博客
07-04 1390
注意：真正意义上的，插入数据和删除数据，还是要根据相应的容器调用其中的函数（比如：push_back,pop_back）堆就是如图，像这样一种连续的数据，但是注意0的位置不存储数据，目的是为了让编号一置。入堆（不是传的数据，只是每一次调用，让你变成堆的形式），起到一个调整数据位置的作用。这个排序默认，也就是简单的从小到大排序，当然第三个参数，你应该也可以写比较准则。出堆的时候，先调用这个函数，将第一个元素，放到最后面，然后用尾删法，删除数据。在插入数据的时候，调用这个函数，将其变为堆的形式。
堆排序 减治法——C++代码
05-24
堆排序是一种基于比较的排序算法，它利用了数据结构中的“堆”这一概念。在计算机科学中，堆通常被理解为一个完全二叉树，其中每个父节点的值都大于或等于（大顶堆）或小于或等于（小顶堆）其子节点的值。堆排序算法...
Huffman.rar_数据结构_Visual_C++_
08-11
《哈弗曼编码在数据结构中的应用——Visual C++实现》 哈弗曼编码是一种用于数据压缩的高效编码方法，由David A. Huffman在1952年提出。它的核心思想是通过构建一棵特殊的二叉树（哈弗曼树）来实现字符的编码，使得...
数据结构——使用C++语言描述
03-20
- 堆的定义：一种特殊的完全二叉树，分为大顶堆和小顶堆。 - 堆的应用：堆排序、优先队列（C++中的std::priority_queue）。 9. **第09章：图论算法** - 拓扑排序：有向无环图（DAG）的线性排序。 - Kruskal和...
排序算法实现_C++
11-12
掌握它们的原理和C++实现，对于提升编程能力，尤其是在处理大规模数据时优化程序性能，具有显著的意义。通过实际编写和调试代码，可以加深对算法的理解，也有助于你在面对实际问题时能够灵活运用这些工具。
C++小顶堆的类模板实现
03-03
C++小顶堆的实现，其中用到了类模板的知识，代码附有详细注释，主函数中附上了测试代码。欢迎私信讨论！
东北大学数据结构实验四完整源代码
09-13
6. **堆**：大顶堆或小顶堆的实现，常用于优先队列。 7. **动态规划**：解决一些优化问题，如背包问题、最长公共子序列等。 8. **链表**：单链表、双链表的操作，包括插入、删除和遍历。 9. **栈和队列**：后进先出...
创建大顶堆代码+时间复杂度详解+归纳过程！
m0_74843368的博客
12-01 1428
大家可能在看了上述代码后认为向下调整shiftDown(int parent,int len)函数的时间复杂度为 logN, 创建堆createHeap()这个函数的时间复杂度为N, 所以创建大根堆时间复杂度为 N * logN , 但其实这个结果是不正确的，创建大根堆正确的时间复杂度其实为O(N)。 下面请大家跟着我以数学公式的方法进行推导： 其中，每个父亲节点都需要和孩子节点进行值的比较，如果孩子的值大于父亲的值，则需要进行向下调整，即将父亲的值和孩子的值进行交换，以确保每个父亲节点的值均大于孩子节
Day 21：C++STL算法篇(2/2)
zjjaibc的博客
07-01 519
①排列组合算法②算术算法③生成异变算法④关系算法⑤集合算法⑥堆算法
数据结构--知识点16--搜索算法(二叉树)
ANingL的博客
09-06 2948
文章目录一、树的概念1、特点2、树的术语3、树的种类4、树的存储与表示5、常见的树的应用场景二、二叉树1、概念2、性质 一、树的概念 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构 1、特点 每个节点有零个或多个子节点 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点外，每个子节点可以分为**多个不相交(因为都只有一个父节点)**的子树 2、树的术语 节点的度：一个节点含有的子树的个数称为该节点的度 树的度：一棵树中，最大的节点的度称为树的度 叶节点或终端节点
C++ priority_queue用法（大顶堆，小顶堆）
热门推荐
MingjaLee's Blog
10-03 4万+
cplusplus.com template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> > class priority_queue; 例子 #include <iostream> #include <string> #include <algori
STL源码分析之大顶堆
博客
06-07 950
关于大顶堆和小顶堆这里就不再介绍了，这里通过STL再次回顾一下。 heap为了适应容器大小的不断变化，底层调用vector实现 关于heap的算法（这里是大顶堆）   push_heap（）算法 为了满足完全二叉树的条件，新加入的元素一定是放在最下一层作为叶节点，并填补在由左至右的第一个空格，即插在vector的end()处     我们通过上溯，将新节点与其父节点
《数据结构、算法与应用(c++语言描述)》习题参考答案.pdf
11-16
《数据结构、算法与应用(c++语言描述)》习题参考答案.pdf

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值