1. Toy模板网首页
  2. > Toy博客

数据结构：大顶堆、小顶堆

8月前 作者：SecureCode 分类：Toy博客 阅读(32) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构：大顶堆、小顶堆。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言：

       堆是其中一种非常重要且实用的数据结构。堆可以用于实现优先队列，进行堆排序，以及解决各种与查找和排序相关的问题。本文将深入探讨两种常见的堆结构：大顶堆和小顶堆，并通过 C++ 语言展示如何实现和使用它们。

1. 什么是大顶堆和小顶堆？

前提：

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

        下面是完全二叉树和不完全二叉树的示意图：

小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++

大顶堆：

        根节点（堆顶元素）是所有节点中的最大值（父节点都大于左右子节点）。大顶堆常用于实现优先队列，且可用于构建堆排序算法。

小顶堆：

        小顶堆中的根节点是所有节点中的最小值（父节点都小于左右子节点）。小顶堆常用于问题如：查找流中的前 K 个最小元素。

示意图：

2. 大小顶堆的底层实现

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

代码：

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个指针。

图示： 

小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++

3. 代码实现小顶堆

3.1 定义小顶堆类

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;//堆数组当前大小
};

3.2 构造函数

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。

3.3 插入

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

比如我按20->30->15->10->9->8->12依次插入，插入示意图如下：

小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++

代码入下：
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
}

        currentSize表示的是当前堆数组有多少个元素。如下图，比如currentSize = 3，表明当前有3个数据。再push一个数据时，在数组的存储的位置刚好是索引3。

示意图：

        如下图，节点7和节点4的父节点都是节点2。节点7的索引为1，节点4索引为2，节点2的索引为0，所以计算7 4 节点的父节点公式为==（索引-1）/2==，其他节点也一样。这里你不从数组索引角度，从树的层序角度也是一样，只不过公式要变为：层序号/2。
小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++

扩大堆数组容量
        在上述代码中，当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++编译器是不检查数组越界的，所以，即使程序员不自己扩容，使用越界的索引程序也不会报错，只是它会继续向下占用一块内存。程序员必须注意数组越界的问题。

3.4 删除

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

小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++

代码如下：
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。
验证循环的真确性，只需考虑以下三种情况，大家可自行验证。

小顶堆,数据结构,完全二叉树（大顶推，小顶堆）,c++
析构函数：
        析构只需将申请的内存释放即可。

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

4. 代码实现大顶堆

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

#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

5. 测试

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

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++ 

总结

        大顶堆和小顶堆都是堆数据结构的变种，它们分别能够在 O(1) 时间内访问最大和最小元素。在 C++ 中，可以方便地使用 std::priority_queue 创建并操作这两种堆。无论是大顶堆还是小顶堆，插入元素和删除堆顶元素的时间复杂度都是 O(log n)，其中 n 为堆中的元素数量。文章来源地址https://www.toymoban.com/news/detail-767193.html

到了这里，关于数据结构：大顶堆、小顶堆的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • LeetCode·每日一题·1851. 包含每个查询的最小区间·优先队列(小顶堆)

    LeetCode·每日一题·1851. 包含每个查询的最小区间·优先队列(小顶堆)

        离线查询：  输入的结果数组queries[]是无序的。如果我们按照输入的queries[]本身的顺序逐个查看，时间复杂度会比较高。 于是，我们将queries[]数组按照数值大小，由小到大逐个查询，这种方法称之为离线查询。 位运算：  离线查询的时候，queries[]可以按照数值大小逐个

    2024年02月16日
    浏览(39)
  • 数据结构：有向完全图和无向完全图的边数

    数据结构：有向完全图和无向完全图的边数

    一个拥有n个结点的无向完全图的边数为：n×(n−1)÷2 具体的解释： 比如我们有一个拥有4个结点的无向完全图， 我们首尾依次连接，共有4条边。 然后我们选择其他的两条边来连线。 又多出了2条边。一共有4 + 2 = 6条边。 我们来分析一下具体的过程，首先如果为n个结点的话，

    2024年02月11日
    浏览(34)
  • 数据结构：完全二叉树（递归实现）

    数据结构：完全二叉树（递归实现）

           如果完全二叉树的深度为h，那么除了第h层外，其他层的节点个数都是满的，第h层的节点都靠左排列。        完全二叉树的编号方法是从上到下，从左到右，根节点为1号节点，设完全二叉树的节点数为sum，某节点编号为i，        当2*i = sum时，有左孩子，其编号为

    2024年01月24日
    浏览(39)
  • 数据结构：非完全二叉树（递归实现）

    数据结构：非完全二叉树（递归实现）

      非完全二叉树是指在二叉树中，除了叶子节点（无子节点）外，其他节点的子节点个数可以不同，即不一定是每个节点都有两个子节点，有右孩子时也不一定有左孩子。 tree.h tree.c main.c 结果

    2024年01月21日
    浏览(32)
  • 数据结构:完全二叉树开胃菜小练习

    数据结构:完全二叉树开胃菜小练习

    目录 一.前言 二.完全二叉树的重要结构特点 三.完全二叉树开胃菜小练习 1.一个重要的数学结论 2.简单的小练习 关于树及完全二叉树的基础概念(及树结点编号规则)参见 : http://t.csdn.cn/imdra http://t.csdn.cn/imdra 完全二叉树是一种非常重要的数据结构: n个结点的完全二叉树 的 结点

    2024年02月02日
    浏览(30)
  • 【数据结构】由完全二叉树引申出的堆的实现

    【数据结构】由完全二叉树引申出的堆的实现

    关于“堆”，百度百科上是这么说的： ——————————引自百度百科 由上面可知，我们可以将堆理解成一个数组，也可以理解成一个完全二叉树。 其实由于完全二叉树的特殊性，其本身就可以使用一个数组来存储。 在之前的二叉树的实现中，我们已经知道完全二叉树

    2024年02月08日
    浏览(34)
  • 数据结构----完全二叉树的时间复杂度讲解,堆排序

    数据结构----完全二叉树的时间复杂度讲解,堆排序

    目录 一.建堆的时间复杂度 1.向上调整算法建堆 2.向下调整算法建堆 二.堆排序 1.概念 2.代码思路 3.代码实现 我们就以极端情况考虑时间复杂度(满二叉树+遍历所有层) 假设所有节点个数为N,树的高度为h N = 2^0+2^1+2^2......+2^(h-1) 即N = 2^h - 1 h = log(N+1) 时间复杂度我们以交换次数为

    2024年03月14日
    浏览(55)
  • 【算法与数据结构】222、LeetCode完全二叉树的节点个数

    【算法与数据结构】222、LeetCode完全二叉树的节点个数

    所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。    思路分析 ：利用层序遍历，然后用num++记录节点数量。其他的例如递归法和迭代法也是如此。    层序遍历程序如下 ： 复杂度分析： 时间复杂度： O ( n ) O(n) O ( n ) 。 空间复杂度： O ( n )

    2024年02月15日
    浏览(36)
  • 【C语言/数据结构】二叉树（层序遍历|判断完全二叉树|性质）

    【C语言/数据结构】二叉树（层序遍历|判断完全二叉树|性质）

     🌈个人主页： 秦jh__https://blog.csdn.net/qinjh_?spm=1010.2135.3001.5343 🔥 系列专栏： 《数据结构》https://blog.csdn.net/qinjh_/category_12536791.html?spm=1001.2014.3001.5482 ​ ​​​ 目录  层序遍历  层序遍历函数实现 判断二叉树是否为完全二叉树 二叉树性质        💬 hello! 各位铁子们大

    2024年01月24日
    浏览(38)

  • 数据结构|连通图、完全图、无向图、有向图的边数计算问题

    完全图 也称简单完全图。一个图任意两个顶点之间都有边的话，该图就称为完全图。 连通图（一般都是指无向图） 如果图中任意俩顶点都连通，则该图为连通图。 有向图 由点和弧所构成的图（ 强连通图必然是有向图，因为强连通和弱连通的概念只在有向图中存在 ） 无向

    2023年04月08日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包