树

最新推荐文章于 2022-01-18 08:59:00 发布

那一次，回眸

最新推荐文章于 2022-01-18 08:59:00 发布

阅读量119

点赞数

本文链接：https://blog.csdn.net/qq_45132890/article/details/105303088

版权

树
树状图是一种数据结构,它是由 n(n>=1) 个有限节点组成一个具有层次关系的集合,把它叫 “树” 是因为它看起来像一颗倒挂的树,也就是说它是根朝上,叶超下的,它具有以下特点:
1.每个节点有0个或多个子节点: 没有父节点的节点称为根节点, 每一个非根节点只有一个父节点,除了根
节点外,每个子节点可以分为多个不相交的子树:

专业术语        中 文                    描 述 
Root           根节点 					一棵树的顶点 
Child		   孩子节点 					一个结点含有的子树的根结点称为该结点的子结点 
Leaf 		   叶子节点 					没有孩子的节点 
Degree			 度 					一个节点包含的子树的数量 
Edge 			 边 					一个节点与另外一个节点的连接 
Depth 			深度 					根节点到这个节点经过的边的数量 
Height		   节点高度 					从当前节点到叶子节点形成路径中边的数量 
Level		    层级 					节点到根节点最长路径的边的总和 
Path 			路径 					一个节点和另一个节点之间经过的边和 Node 的序列

二叉树
每个节点最多只能有两个分支的树,左边的分支称为左子树,右边的分支称为右子树;
计算方式为:
1.在非空的二叉树中,第 i-1 层的节点总数不超过 2的i-1次方,i>=1;
2.深度为 h-1 的二叉树最多有 2的h次方-1 个节点(h>=1) 最少有h个节点;
3.对于任意一颗二叉树,如果其节点点为 N0, 而度数为 2 的节点总数为 N2, 则 N0=N2+1;

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

满二叉树:
除了叶结点外每一个结点都有左右子节点且叶子结点都处在最底层的二叉树;

平衡二叉树:
又被称为 AVL 树，它是一颗空树或左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树

二叉搜索树:
又称二叉查找树、二叉排序树（Binary Sort Tree）。它是一颗空树或是满足下列性质的二叉树：
1）若左子树不空，则左子树上所有节点的值均小于或等于它的根节点的值；
2）若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值；
3）左、右子树也分别为二叉排序树。

红黑树:
是每个节点都带有颜色属性（颜色为红色或黑色）的自平8衡9二7叉94查3找8树40，1满1足1下1列性质：
1）节点是红色或黑色；
2）根节点是黑色；
3）所有叶子节点都是黑色；
4）每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。)
5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

二叉搜索树代码实现:

#pragma once
#include <iostream>
#include <Windows.h>

using namespace std;

//创建一个二叉查找树
#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;//左孩子节点
	struct  _Bnode* rchild;//右孩子节点
}Bnode,Btree;

//预先分配空间,这个数值根据实际需要预估确定
#define MaxSize 64 

//使用栈保存树的元素
typedef struct _SqStack {
	Bnode* base;//栈底指针
	Bnode* top;//栈顶指针
}SqStack;

bool initStack(SqStack& stack);
bool pushStack(SqStack& stack, Bnode& elem);
bool isEmpty(SqStack& stack);
bool popStack(SqStack& stack, Bnode& node);
void DestroyStack(SqStack& stack);

//插入节点到树中
bool insertBtree(Btree** root, Btree* node) {
	Bnode* tmp = NULL;
	Bnode* parent = NULL;
	
	if (!node) {
		return false;
	}else{
		//清空新节点的左右子树
		node->lchild = NULL;
		node->rchild = NULL;
	}

	if (*root) {
		//存在根节点
		tmp = *root;
	}else {
		//不存在根节点
		*root = node;
		return true;
	}

	while (tmp != NULL) {
		//保存父节点
		parent = tmp;
		if (isLess(node->data, tmp->data)) {
			tmp = tmp->lchild;
		} else {
			tmp = tmp->rchild;
		}
	}

	//若该树为空树,则直接将node放在根节点上
	if (isLess(node->data, parent->data)) {
		//找到空位置后,进行插入
		parent->lchild = node;
	}else {
		parent->rchild = node;
	}

	return true;
}

//采用二叉搜索树上最大的节点
ElemType findMax(Btree* root) {
	if (root->rchild == NULL) {
		return root->data;
	}
	return findMax(root->rchild);
}

//采用递归方式删除节点
Btree* DeleteNode(Btree* root, int key, Bnode** deleteNode) {
	if (root == NULL) {
		return NULL;
	}

	if (root->data > key) {
		root->lchild = DeleteNode(root->lchild, key, deleteNode);
		return root;
	}

	if (root->data < key) {
		root->rchild = DeleteNode(root->rchild, key, deleteNode);
		return root;
	}

	deleteNode = &root;

	//删除节点不存在左右子节点,即为叶子节点,直接删除
	if (root->lchild == NULL && root->rchild == NULL) {
		return NULL;
	}

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

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

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

	return root;
}

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

//不使用递归查找节点
Bnode* QueryByLoop(Bnode* root, ElemType node) {
	while (root != NULL && !isEqual(root->data, node)) {
		if (isLess(node, root->data)) {
			return root->lchild;
		} else {
			return root->rchild;
		}
	}
	return root;
}

//使用递归方式实现前序遍历
void PreOrderRec(Btree* root) {
	if (root == NULL) {
		return;
	}

	printf("**%d**", root->data);
	PreOrderRec(root->lchild);
	PreOrderRec(root->rchild);
}

//借助栈实现前序遍历
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);
}

//初始化一个栈
bool initStack(SqStack& stack) {
	//为顺序栈分配一个最大容量为MaxSize的空间
	stack.base = new Bnode[MaxSize];

	if (!stack.base) {
		return false;
	}

	//top初始为base,空栈
	stack.top = stack.base;
	return true;
}

//插入元素elem为新的栈顶元素
bool pushStack(SqStack& stack, Bnode& elem) {
	if (stack.top - stack.base == MaxSize) {
		return false;//栈满
	}

	*(stack.top++) = elem;

	return true;
}

//判断栈是否为空
bool isEmpty(SqStack& stack) {
	if (stack.top == stack.base) {
		return true;
	}

	return false;
}

//删除栈顶元素,暂存在变量node
bool popStack(SqStack& stack, Bnode& node) {
	if (isEmpty(stack)) {
		return false;
	}

	node = *(--stack.top);

	return true;
}

//销毁栈
void DestroyStack(SqStack& stack) {
	if (stack.base) {
		delete stack.base;
		stack.base = NULL;
		stack.top = NULL;
	}
}

树的企业级应用案例:
1 哈夫曼编码:
哈夫曼（Huffman）编码算法是基于二叉树构建编码压缩结构的，它是数据压缩中经典的一种算法。算法根据文本字符出现的频率，重新对字符进行编码。
代码实现:

#include <stdio.h>//C标准库头文件
#include <assert.h>//断言函数头文件
#include <stdlib.h>//控制台函数头文件
#include <iostream>

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* QuePtr;

//定义一个队列
typedef struct Queue {
	int length;//队列长度
	QuePtr front;//队首指针
	QuePtr rear;//队尾指针
}linkQueue;

//队列初始化
bool initQueue(linkQueue* LQ) {
	if (!LQ) {
		return false;
	}
	LQ->length = 0;
	//把队首和队尾指针同时设为空
	LQ->front = NULL;
	LQ->rear = NULL;

	return true;
}

//判断队列是否为空
bool isNull(linkQueue* LQ) {
	if (!LQ||LQ->front!=NULL) {
		return false;
	}
	return true;
}

//判断队列是否为满
bool isFull(linkQueue* LQ) {
	if (!LQ || LQ->length != MaxSize) {
		return false;
	}
	return true;
}

//入队,将元素elem插入到队列LQ中
bool enterQueue(linkQueue* LQ, DataType elem, int priority) {
	if (!LQ || isFull(LQ)) {
		return false;
	}

	Qnode* node = new Qnode;
	node->data = elem;
	node->priority = priority;
	node->next = NULL;

	if (isNull(LQ)) {
		//空队列
		LQ->front = LQ->rear = node;
	}
	else {
		//不是空队列在队尾插入节点node,队尾指向新插入的节点
		node->next = LQ->front;
		LQ->front = node;
		//LQ->rear->next = node;
		//LQ->rear = node;
	}

	LQ->length++;

	return true;
}

//出队,遍历队列,找到队列中优先级最高的元素elem出队
int popQueue(linkQueue* LQ, DataType* elem) {
	if (!LQ || isNull(LQ)||!elem) {
		return 0;
	}

	//保存当前已选出的最高优先级节点的上一个节点的指针地址
	Qnode** prev = NULL;
	Qnode* prev_node = NULL;
	Qnode* tmp = NULL;
	Qnode* last = NULL;

	//prev指向队首front指针的地址
	prev = &(LQ->front);
	last = LQ->front;
	tmp = last->next;
	while (tmp) {
		if (tmp->priority < (*prev)->priority) {
			prev = &(last->next);
			prev_node = last;
		}

		last = tmp;
		tmp = tmp->next;
	}

	*elem = (*prev)->data;
	tmp = *prev;
	*prev = (*prev)->next;

	delete tmp;

	LQ->length--;

	//接下来可能存在的两种情况需要分别处理
	//1.删除的是首节点,而且队列长度为0时
	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) {
	if (!LQ || LQ->front == NULL) {
		return;
	}

	QuePtr tmp;
	tmp = LQ->front;

	while (tmp) {
		printf("元素为:%d,优先级:%d\n", tmp->data->value, tmp->priority);
		tmp = tmp->next;
	}

	printf("\n");
}

//获取队首元素
int getHead(linkQueue* LQ, DataType* elem) {
	if (!LQ || isNull(LQ)||!elem) {
		return 0;
	}

	*elem = LQ->front->data;

	return 1;
}

//清空队列
void clearQueue(linkQueue* LQ) {
	if (!LQ) {
		return;
	}

	while (LQ->front) {
		QuePtr tmp = LQ->front->next;
		delete LQ->front;
		LQ->front = tmp;
	}

	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

//构造哈夫曼编码
void huffManTree(Btree** huff, int n) {
	linkQueue* LQ = new linkQueue;
	int i = 0;

	//初始化队列
	initQueue(LQ);

	//初始化存放哈夫曼树的数组 huffNode[] 中的节点
	for (int i = 0; i < n; i++) {
		Bnode* node = new Bnode;

		printf("输入第%d个字符和出现的频率:\n", i + 1);
		cin >> node->value;
		cin >> node->weight;

		node->parent = NULL;
		node->rchild = NULL;
		node->lchild = NULL;

		enterQueue(LQ, node, node->weight);
	}

	printQueue(LQ);

	do {
		Bnode* node1 = NULL;
		Bnode* node2 = NULL;
		Bnode* node3 = NULL;

		if (!isNull(LQ)) {
			popQueue(LQ, &node1);
			printf("第一个出队的数: %c,优先级:%d\n", node1->value, node1->weight);
		}
		else {
			break;
		}

		if (!isNull(LQ)) {

			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("**%d**", root->value);
	preOrderRec(root->lchild);
	preOrderRec(root->rchild);
}

//测试函数
int main(void) {

	Btree* tree = NULL;

	huffManTree(&tree, 5);
	preOrderRec(tree);

	system("pause");
	return 0;
}

那一次，回眸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
树

树树状图是一种数据结构,它是由 n(n>=1) 个有限节点组成一个具有层次关系的集合,把它叫 “树” 是因为它看起来像一颗倒挂的树,也就是说它是根朝上,叶超下的,它具有以下特点:1.每个节点有0个或多个子节点: 没有父节点的节点称为根节点, 每一个非根节点只有一个父节点,除了根节点外,每个子节点可以分为多个不相交的子树:专业术语中文 ...
复制链接

扫一扫

树

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