破“树”式

最新推荐文章于 2023-10-18 11:32:56 发布
最新推荐文章于 2023-10-18 11:32:56 发布
阅读量303 收藏
点赞数
分类专栏： 独孤九剑——九破数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34850023/article/details/107262511
版权

树

在这里插入图片描述
树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

它具有以下的特点： 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除 了根结点外，每个子结点可以分为多个不相交的子树；
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二叉树

一个没有限制的线性表应用范围可能有限，但是我们对线性表进行一些限制就可 以衍生出非常有用的数据结构如栈、队列、优先队列等。

树也是一样，一个没有限制的树由于太灵活，控制起来比较复杂。如果对普通的树加上一些人为的限制，比如 节点只允许有两个子节点，这就是我们接下来要介绍的二叉树。

二叉树是一个每个结点最多只能有两个分支的树，左边的分支称之为左子树，右边的分支称之为右子树。

在这里插入图片描述
在这里插入图片描述

常见二叉树分类：

（1）完全二叉树 ： 若设二叉树的高度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层有叶 子节点，并且叶子结点都是从左到右依次排布，这就是完全二叉树（堆就是完全二叉树）。

在这里插入图片描述
（2）满二叉树 ： 除了叶结点外每一个结点都有左右子节点且叶子结点都处在最底层的二叉树。
在这里插入图片描述
（3）平衡二叉树 ：又被称为 AVL 树，它是一颗空树或左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都 是一棵平衡二叉树。
在这里插入图片描述
（4）二叉搜索树 ： 又称二叉查找树、二叉排序树（Binary Sort Tree）。

它是一颗空树或是满足下列性质的二叉树：

1）若左子树不空，则左子树上所有节点的值均小于或等于它的根节点的值；

2）若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值；

3）左、右子树也分别为二叉排序树。

在这里插入图片描述
（5）红黑树 ： 是每个节点都带有颜色属性（颜色为红色或黑色）的自平衡二叉查找树，满足下列性质：

1）节点是红色或黑色；

2）根节点是黑色；

3）所有叶子节点都是黑色；

4）每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节 点。)

5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

在这里插入图片描述

二叉搜索树的算法实现

当我们要在一组数中要找到一个数，比如 26？你该怎么找？
在这里插入图片描述
当我们把数据进行排序（按照从小到大的顺序排列）后，再查找相应的这条记录？还是用上面的方法吗？
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
节点结构体的定义:

#define MAX_NODE 1024 
#define isLess(a, b) (a<b) 
#define isEqual(a, b) (a==b) 

typedef int ElemType;
typedef struct _Bnode{ 
	ElemType data; //元素类型 
	struct _Bnode *lchild, *rchild;//指向左右孩子节点 
}Bnode, *Btree;

 
二叉搜索树插入节点

将要插入的结点 e，与节点 root 节点进行比较，若小于则去到左子树进行比较，若大于则去到右子树进行比较，重复以上 操作直到找到一个空位置用于放置该新节点。

bool InsertBtree(Btree **root, Bnode *node){ 
	Bnode *tmp = NULL; 
	Bnode *parent = NULL; 
	
	if(!node){ 
		return false; 
	}else {//清空新节点的左右子树 
		node->lchild = NULL; 
		node->rchild = NULL; 
	}
	
	if(*root){//存在根节点 
		tmp= *root; 
	}else{ //若该树为空树,则直接将 node 放置在根节点上
		*root = node; 
		return true; 
	}
	
	while(tmp != NULL){ 
		parent = tmp;//保存父节点 
		printf("父节点： %d\n", parent->data); 
	
		if(isLess(node->data,tmp->data)){ 
			tmp = tmp->lchild; 
		}else{ 
			tmp = tmp->rchild; 
		} 
	}

	 
	if(isLess(node->data, parent->data)){
		//找到空位置后，进行插入 
		parent->lchild = node; 
	}else{ 
		parent->rchild = node; 
	}
	return true; 
}

 

二叉搜索树删除节点

将要删除的节点的值，与节点 root 节点进行比较，若小于则去到左子树进行比较，若大于则去到右子树进行比较，重复以 上操作直到找到一个节点的值等于删除的值，则将此节点删除。删除时有 4 中情况须分别处理：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/************************ * 
查找二叉搜索树上最大的结点 
*************************/ 
int findMax(Btree* root) { 

	assert(root!=NULL); 
	//方式一 采用递归 
	/*if(root->rchild==NULL){ 
		return root->data; 
	}
	return findMax(root->rchild); */

	//方式二 采用循环 
	while(root->rchild){ 
		root = root->rchild; 
	}
	return root->data; 
}
	
	
/************************ * 
采用递归方式查找结点 
*************************/
Btree* DeleteNode(Btree* root, int key){ 
	if(root==NULL)return NULL;//没有找到删除节点 
	if(root->data > key) { 
		root->lchild = DeleteNode(root->lchild, key); 
		return root; 
	}
	
	if(root->data < key) { 
		root->rchild = DeleteNode(root->rchild, key); 
		return root; 
	}
	
	//删除节点不存在左右子节点，即为叶子节点，直接删除 
	if(root->lchild==NULL && root->rchild==NULL)
		return NULL; 

	//删除节点只存在右子节点，直接用右子节点取代删除节点 
	if(root->lchild==NULL && root->rchild!=NULL)
		return root->rchild; 

	//删除节点只存在左子节点，直接用左子节点取代删除节点 
	if(root->lchild!=NULL && root->rchild==NULL)
		return root->lchild; 

	//删除节点存在左右子节点，直接用左子节点最大值取代删除节点 
	int val = findMax(root->lchild); 
	root->data=val; 
	root->lchild = DeleteNode(root->lchild,val); 
	return root; 
}

 

二叉搜索树搜索

/************************ * 
采用递归方式查找结点 
*************************/ 
Bnode* queryByRec(Btree *root, ElemType e){ 
	if (root == NULL || isEqual(root->data, e)){ 
		return root; 
	} else if(isLess(e, root->data)) { 
		return queryByRec(root->lchild, e); 
	} else { 
		return queryByRec(root->rchild, e); 
	} 
}

/** * 使用非递归方式查找结点 */
Bnode* queryByLoop(Bnode *root, int e){ 
		while(root != NULL && !isEqual(root->data, e)){ 
			if(isLess(e, root->data)){ 
				root = root->lchild; 
			}else{ 
				root = root->rchild; 
			} 
		}
		return root; 
}

 

二叉树的遍历

二叉树的遍历是指从根结点出发，按照某种次序依次访问所有结点，使得每个结点被当且访问一次。共分为四种方式：

前序遍历 - 先访问根节点，然后前序遍历左子树，再前序遍历右子树
在这里插入图片描述
上图前序遍历结果： 19 7 5 11 15 25 21 61

/************************ * 
采用递归方式实现前序遍历 
*************************/ 
void PreOrderRec(Btree *root) { 
	if (root == NULL) { 
		return; 
	}
	printf("- %d -", root->data); 
	preOrderRec(root->lchild); 
	preOrderRec(root->rchild); 
}

 
前序遍历 - 非递归方式实现:

首先申请一个新的栈，记为 stack； 将头结点 head 压入 stack 中； 每次从 stack 中弹出栈顶节点，记为 cur，然后打印 cur 值，如果 cur 右孩子不为空，则将右孩子压入栈中；如果 cur 的左 孩子不为空，将其压入 stack 中； 重复步骤 ，直到 stack 为空

/************************ * 
借助栈实现前序遍历 
*************************/ 
void PreOrder(Btree *root) { 
	Bnode cur ; 
	if (root == NULL) { 
		return; 
	}
	
	SqStack stack; 
	
	InitStack(stack); 
	PushStack(stack, *root); //头节点先入栈 
	
	//栈为空，所有节点均已处理
	while (!(IsEmpty(stack)))  { 
		PopStack(stack, cur); //要遍历的节点 
		printf("- %d -", cur.data); 
		
		if (cur.rchild != NULL) { 
			PushStack(stack, *(cur.rchild)); 
			//右子节点先入栈，后处理 
		}
		
		if (cur.lchild != NULL) { 
			PushStack(stack, *(cur.lchild)); 
			//左子节点后入栈，接下来先 处理 
		} 
	}
	DestroyStack(stack); 
}

 
中序遍历 - 先访问根节点的左子树，然后访问根节点，最后遍历右子树
在这里插入图片描述

 
后序遍历 - 从左到右，先叶子后节点的方式遍历访问左右子树，最后访问根节点
在这里插入图片描述

 
层序遍历 - 从根节点从上往下逐层遍历，在同一层，按从左到右的顺序对节点逐个访问
在这里插入图片描述
 

哈夫曼编码

哈夫曼（Huffman）编码算法是基于二叉树构建编码压缩结构的，它是数据压缩中经典的一种算 法。算法根据文本字符出现的频率，重新对字符进行编码。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

编码实现

Huff.h

#pragma once 

#include <stdio.h> 
#include <assert.h> 
#include <Windows.h> 
#include <iostream> 
#include <iomanip> 

using namespace std; 

#define MaxSize 1024 //队列的最大容量 

typedef struct _Bnode { 
	char value; 
	int weight; 
	struct _Bnode *parent; 
	struct _Bnode *lchild; 
	struct _Bnode *rchild; 
} Btree, Bnode; /* 树结点结构体 */ 


typedef Bnode *DataType; //任务队列中元素类型 

typedef struct _QNode { //队列结点结构 
	/*每个节点的优先级,数值越大，优先级越高，
	优先级相同， 取第一个节点 */
	int priority; 
	DataType data; 
	struct _QNode *next; 
}QNode; 

typedef QNode * QueuePtr; 


typedef struct Queue { //队头结构
	int length; //队列的长度 
	QueuePtr front; //队头指针 
	QueuePtr rear; //队尾指针 
}LinkQueue;


//队列初始化，将队列初始化为空队列 
void InitQueue(LinkQueue *LQ) { 
	if(!LQ) return ; 
	LQ->length = 0; 
	LQ->front = LQ->rear = NULL; //把对头和队尾指针同时置 0 
}

//判断队列为空 
int IsEmpty(LinkQueue *LQ) { 
	if(!LQ) return 0; 
	if (LQ->front == NULL) { 
		return 1; 
	}
	return 0; 
}

//判断队列是否为满 
int IsFull(LinkQueue *LQ) { 
	if(!LQ) return 0; 
	if (LQ->length == MaxSize) { 
		return 1; 
	}
	return 0; 
}

//入队,将元素 data 插入到队列 LQ 中 
int EnterQueue(LinkQueue *LQ,DataType data,int priority){ 
	if(!LQ) return 0; 
	if(IsFull(LQ)){ 
		cout<<"无法插入元素 "<<data<<", 队列已满!"<<endl; 
		return 0; 
	}

	QNode *qNode = new QNode; 
	qNode->data = data; 
	qNode->priority = priority; 
	qNode->next = NULL;
	
	if(IsEmpty(LQ)){//空队列 
		LQ->front = LQ->rear = qNode; 
	}else { 
		qNode->next = LQ->front; //在对头插入节点
		LQ->front = qNode; 
		//LQ->rear->next =qNode;//在队尾插入节点 qNode 
		//LQ->rear = qNode; //队尾指向新插入的节点 
	}
	LQ->length++; 
	return 1; 
}


//出队，遍历队列，找到队列中优先级最高的元素 data 出队 
int PopQueue(LinkQueue *LQ, DataType *data){ 
	//保存当前已选举的最高优先级节 点上一个节点的指针地址。
	QNode **prev = NULL, *prev_node=NULL;
	QNode *last = NULL, *tmp = NULL; 
	
	if(!LQ || IsEmpty(LQ)){ 
		cout<<"队列为空！"<<endl; 
		return 0; 
	}
	
	if(!data) return 0;
	//prev 指向队头 front 指针的地址 
	prev = &(LQ->front); 
	//printf("第一个节点的优先级: %d\n", (*prev)->priority); 
	last = LQ->front; 
	tmp = last->next; 
	
	while(tmp){ 
		if(tmp->priority <(*prev)->priority){ 
			//printf("抓到个更小优先级的节点[priority: %d]\n", tmp->priority); 
			prev = &(last->next); 
			prev_node= last; 
		}
		last=tmp; 
		tmp=tmp->next; 
	}
	
	*data = (*prev)->data; 
	tmp = *prev; 
	*prev = (*prev)->next;
	
	delete tmp; 
	LQ->length--; 
	
	//接下来存在 2 种情况需要分别对待 
	//1.删除的是首节点,而且队列长度为零 
	if(LQ->length==0){ 
		LQ->rear=NULL; 
	}
	//2.删除的是尾部节点 
	if(prev_node&&prev_node->next==NULL){ 
		LQ->rear=prev_node; 
	}
	return 1; 
}


//打印队列中的各元素 
void PrintQueue(LinkQueue *LQ) { 
	QueuePtr tmp; 
	
	if(!LQ) return ; 
	
	if(LQ->front==NULL){ 
		cout<<"队列为空！"; 
		return ; 
	}
	
	tmp = LQ->front; 
	while(tmp) { 
		cout<<setw(4)<<tmp->data->value<<"["<<tmp->priority<<"]"; 
		tmp = tmp->next; 
	}
	cout<<endl; 
}

//获取队首元素，不出队 
int GetHead(LinkQueue *LQ,DataType *data) { 
	if (!LQ || IsEmpty(LQ)) { 
		cout<<"队列为空!"<<endl; 
		return 0; 
	}
	if(!data) return 0; 
	*data = LQ->front->data; 
	return 1; 
}

//清空队列 
void ClearQueue(LinkQueue *LQ) { 
	if(!LQ) return ; 
	while(LQ->front){ 
		QueuePtr tmp = LQ->front->next; 
		delete LQ->front; 
		LQ->front = tmp; 
	}
	LQ->front = LQ->rear = NULL; 
	LQ->length = 0; 
}

//获取队列中元素的个数 
int getLength(LinkQueue* LQ){ 
	if(!LQ) return 0; 
	return LQ->length; 
}

Huff.cpp

#include <stdio.h> 
#include <stdlib.h> 
#include <iostream> 
#include "Huff.h" 

using namespace std; 

void PreOrderRec(Btree *root);

/* 构造哈夫曼编码树 */ 
void HuffmanTree (Btree * &huff, int n) { 
	LinkQueue *LQ = new LinkQueue; 
	int i = 0;
	
	//初始化队列 
	InitQueue(LQ);
	 
	/* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */ 
	for (i=0; i<n; i++) { 
		Bnode * node = new Bnode; 
		cout<<"请输入第"<<i+1<<"个字符和出现频率: "<<endl; 
		cin>>node->value; //输入字符 
		cin>>node->weight ;//输入权值 
		node->parent =NULL; 
		node->lchild =NULL; 
		node->rchild =NULL; 
		
		EnterQueue(LQ, node, node->weight); 
	}


	PrintQueue(LQ); 

	do{ 
			Bnode *node1 = NULL; 
			Bnode *node2 = NULL; 
		
		if(!IsEmpty(LQ)){ 
			PopQueue(LQ, &node1); 
			printf("第一个出队列的数：%c, 优先级: %d\n", node1->value, node1->weight); 
		}else { 
			break; 
		}
		
		if(!IsEmpty(LQ)){ 
				Bnode *node3 = new Bnode; 
				PopQueue(LQ, &node2); 
				printf("第二个出队列的数：%c, 优先级: %d\n", node2->value, node2->weight); 
				node3->lchild = node1; 
				node1->parent = node3; 
				node3->rchild = node2; 
				node2->parent = node3; 
				node3->value = ' ';
				
				node3->weight=node1->weight+node2->weight; 
				printf("合并进队列的数：%c, 优先级: %d\n", node3->value, node3->weight); 
			
				EnterQueue(LQ,node3, node3->weight); 
		}else { 
			huff = node1; 
			break; 
		} 
	}while(1); 
}


/************************ * 
采用递归方式实现前序遍历 
*************************/ 
void PreOrderRec(Btree *root) { 
	if (root == NULL) { 
		return; 
	}
	printf("- %c -", root->value); 
	PreOrderRec(root->lchild); 
	PreOrderRec(root->rchild); 
}


int main(void){ 
	Btree * tree = NULL; 
	HuffmanTree(tree, 7); 
	PreOrderRec(tree); 
	
	system("pause"); 
	return 0; 
}

 

红黑树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
至此我们的红黑树就构建完成，红黑树的查找同普通的二叉排序树

闲云野雀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
educoder数据结构与算法 队列 第1关：实现一个顺序存储的队列
qq_54008392的博客
12-09 1万+
任务描述 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 相关知识 队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。 顺序存储的队列 队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出
数据结构与算法 - 队列
aiains的博客
10-24 2718
数据结构
数据结构与算法 - 栈（完整代码）
JKR10000的博客
03-28 2077
样例输入: push 56 push 15 push 12 push 13 pop end 样例输出 Stack length: 3 The stack (from top to bottom): 12 15 56 代码如下： #include <stdio.h> #include <stdlib.h> #include <string.h&gt...
数据结构与算法基础之线性表顺序实现(C语言)
zyx18211503935的博客
05-05 345
数据结构与算法基础之线性表顺序实现 学习来源: 数据结构与算法基础（青岛大学-王卓） 地址： https://www.bilibili.com/video/BV1nJ411V7bd?p=22&spm_id_from=pageDriver 背景: 实现视频里老师的伪代码，并不完全一样，但基本雷同。 代码: SequenceList.h #ifndef _SEQUENCELIST_H_ #define _SEQUENCELIST_H_ struct List_SQ { int *Sequ
头歌数据结构-实现一个顺序存储的队列
LQ370534427的博客
06-06 965
第1关：实现一个顺序存储的队列 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 /************************************************************* date: April 2017 copyright: Zhu En DO NOT dist
基于C++树形菜单控件源代码
11-26
首先，"基于C++树形菜单控件源代码"这个标题指出，我们将讨论的是一种用C++编程语言编写的控件，这种控件能够呈现树状的交互式菜单。C++作为面向对象的编程语言，具有强大的性能和灵活性，适合构建复杂的用户界面...
包覆式爆炸成型复合侵彻体成型规律研究
03-10
包覆式爆炸成型复合侵彻体成型规律研究，王树有，蒋建伟，包覆式爆炸成型复合侵彻体是通过炸药爆炸驱动金属药型罩包覆内核活性材料而形成的一种新型高效毁伤元。本文设计了带包覆物的小长
IT销售技巧-摧龙六式.doc
09-09
IT销售技巧-摧龙六式提供了一套完整的销售流程，涵盖了销售前的准备、树破信赖、发掘需要、代价赢取、价钱和休会等六个要害步调和二十四招。通过掌握这套销售技巧，销售团队可以更好地服务客户，提高销售业绩。 ...
七年级下册知识树分析.ppt
10-18
【七年级下册英语知识树分析】 在七年级下册的英语教材中，知识点的编排注重基础性和实用性，旨在促进学生心智成长和人文素质的提高。以下是主要的知识点总结： 1. **语法：** - **一般过去时**：这是最基础的...
SqList.cpp
01-26
该代码为完整的可运行的顺序表及其基本操作代码，实现语言为C语言。包含了顺序表的创建及销毁；顺序表的插入、删除、清空；查询、取指定位置元素以及判断表空、测量表长等基本操作。
顺序线性表1.CPP
10-17
实训课时候上的顺序线性表，不错，大家可以下下来借鉴一下发。。。。
数据结构 - 队列
Name_Larry
04-03 398
队列分为链式队列和静态队列。 静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费。 链式队列是用链表来实现队列的。 循环队列 循环队列需要2个参数，front 和 rear 。 队列初始化时，front 和 rear 都为零。 当队列不为空时，front 指向队列的第一个元素，rear 指向队列最后一个元素的下一个位置。 当队列为空时，fr
队列学习 - 顺序存储法
qq_44914968的博客
10-25 1007
队列学习 - 顺序存储法 1. 队列的原理 队列是一种受限的线性表，(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out). 队列是一种受限的线性结构. 它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。 生活中队列场景随处可见: 比如在电影院, 商场, 或者厕所排队。。。。。。 ...
实现一个顺序存储的栈（数据结构与算法 - 栈）
热门推荐
韶言大雅
04-24 1万+
相关知识 栈的基本概念 栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算，这一端被称为栈顶。栈既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案： 如图 1 所示：该栈存储了 4 个元素 {56,77,15,12} ，其中 12 是栈顶元素。 这种实现方案将栈元素存储在一片连续的空间中，栈相关的三个属性元素data、top和max介绍如下：...
数据结构——栈
Junds0的博客
03-29 584
本关任务是实现 顺序栈的五个操作函数，分别用于实现判断栈满、栈空、求栈的长度、进栈和出栈等功能，对应于程序中的五个函数SqStack_IsFull、SqStack_IsEmpty、SqStack_Length、SqStack_Push和SqStack_Pop。本关任务是实现LinkStack_IsEmpty、LinkStack_Length、LinkStack_Push、LinkStack_Pop和LinkStack_Top五个操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。
实现一个顺序存储的队列2020-12-01
greenhand_com的博客
12-01 2130
Educator错题 实现一个顺序存储的队列 为了操作去思考 #首先，我得定义一个顺序存储的队列 struct SeqQueue { T* data; // 指向数据元素数组的指针 int front; // 下一个出队元素的数组下标 int rear; // 下一个入队元素应该存放的单元的数组下标 int max; // 队列中最多可放max-1个数据元素，留一个空数据单元以区分空和满 }; 在此基础上，我需要定义对于队列的操作，如出队、进队、判断是否为满、是否为空。
队列：SeqQueue（循环队列/顺序队列）的全代码
2203_75582171的博客
10-18 386
【代码】队列：SeqQueue（循环队列/顺序队列）的全代码。
破圈法实现最小生成树
最新发布
06-18
破圈法，也称为Prim算法（Prim's algorithm），是一种用于寻找无向加权图中最小生成树的算法。最小生成树是指在图中连接所有顶点的边的总权重最小的树。Prim算法的主要思想是从一个初始顶点开始，逐步添加与现有树相连且权重最小的边，直到所有顶点都被包含在内。 以下是Prim算法实现最小生成树的基本步骤： 1. 初始化：选择一个起始顶点（通常是最小权重的顶点或任意一个），并将其加入到已访问集合中，形成初始树。 2. 扩展过程：对于未访问的顶点集合，计算它们到当前已访问集合中所有顶点的最短边（权重）。找到这个最短边，将边的另一端（未访问的顶点）加入到已访问集合，并更新该顶点的邻接边的权重。 3. 重复步骤2，直到所有的顶点都被添加到已访问集合，形成了最小生成树。 4. 最后，整个过程会得到一个树形结构，其中包含所有顶点，且边的总权重最小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值