树和二叉树代码补充

最新推荐文章于 2023-07-11 11:14:49 发布
最新推荐文章于 2023-07-11 11:14:49 发布
阅读量248 收藏
点赞数
分类专栏： 考研知识摘录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43271844/article/details/107454071
版权
  • 二叉树的顺序存储
#define MaxSize 100
struct TreeNode {
	ElemType value; //结点中的数据元素
	bool isEmpty;   //结点是否为空
};

TreeNode t[MaxSize];

for (int i = 0; i < MaxSize; i++) {
	t[i].isEmpty = true;
}
  • 二叉树的链式存储
struct ElemType {
	int value;
};

typedef struct BiTNode {
	ElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

//定义一棵空树
BiTree root = NULL;

//插入根节点
root = (BiTree)malloc(sizeof(BiTNode));
root->data. = { 1 };
root->lchild = NULL;
root->rchild = NULL;

//插入新结点
BiTNode * p = (BiTNode *)malloc(sizeof(BiTNode));
p->data = { 2 };
p->lchild = NULL;
p->rchild = NULL;
root->lchild = p;  //作为根节点的左孩子
  • 求树的深度
int treeDepth(BiTree T) {
	if (T == NULL) {
		return 0;
	}
	else {
		int l = treeDepth(T->lchild);
		int r = treeDepth(T->rchild);
		//树的深度=Max(左子树深度，右子树深度)+1
		return l > r ? l + 1 : r + 1;
	}
}
  • 层序遍历
//层序遍历
void LevelOrder(BiTree T) {
	LinkQueue Q;
	InitQueue(Q);   //初始化辅助队列
	BiTree p;
	EnQueue(Q, T);  //将根结点入队
	while (!IsEmpty(Q)) { //队列不空则循环
		DeQueue(Q，p);    //队头结点出队
		visit(p);         //访问出队结点
		if (p->lchild != NULL)
			EnQueue(Q, p->lchild); //左孩子入队
		if (p->rchild != NULL)
			EnQueue(Q, p->rchild); //右孩子入队
	}
}
  • 二叉树的链式存储
//二叉树的结点(链式存储)
typedef struct BiTNode {
	char data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

//链式队列结点
typedef struct LinkNode {
	BiTNode * data;
	struct LinkNode *next;
}LinkNode;

typedef struct {
	LinkNode *front, *rear;  //队头队尾
}LinkQueue;
  • 孩子表示法（顺序+链式存储）
struct CTNode {
	int child;  //孩子结点在数组中的位置
	struct CTNode *next; //下一个孩子
};

typedef struct {
	ElemType data;
	struct CTNode *firstChild; //第一个孩子
} CTBox;

typedef struct {
	CTBox nodes[MAX_ TREE_ SIZE];
	int n, r;  //结点数和根的位置
} CTree;
  • 中序线索化
//线索二叉树结点
typedef struct ThreadNode {
	ElemType data;
	struct ThreadNode *lchild, *rchild;
	int ltag, rtag;   //左、右线索标志
}ThreadNode, *ThreadTree;

//中序遍历二叉树，一边遍历一边线索化
void InThread(ThreadTree T) {
	if (T != NULL) {
		InThread(T->lchild); //中序遍历左子树
		visit(T);            //访问根节点
		InThread(T->rchild); //中序遍历右子树
	}
}
void visit(ThreadNode *q) {
		if (q->lchild == NULL) {//左子树为空，建立前驱线索
			q->lchild = pre;
			q->ltag = 1;
		}
		if (pre != NULL && pre->rchild == NULL) {
			pre->rchild = q; //建立前驱结点的后继线索
			pre->rtag = 1;
		}
		pre = q;
}

//中序线索化二叉树T
void CreateInThread(ThreadTree T) {
	pre = NULL;        //pre初始为NULL
	if (T != NULL) {   //非空二叉树才能线索化
		InThread(T);   //中序线索化二叉树
		if (pre->rchild == NULL)
			pre->rtag = 1;  //处理遍历的最后一个结点
	}
}

//全局变量pre,指向当前访问结点的前驱
ThreadNode *pre=NULL;

//中序线索化（王道版）
void InThread(ThreadTree p, ThreadTree &pre) {
	if (p != NULL) {
		InThread(p->lchild, pre); //递归， 线索化左子树
		if (p->lchild == NULL) {  //左子树为空，建立前驱线索
			p->lchild=pre;
			p->ltag = 1;
		}
		if (pre != NULL && pre->rchild == NULL) {
			pre->rchild = p; //建立前驱结点的后继线索
			pre->rtag = 1;
		}
		pre = p;  //标记当前结点成为刚刚访问过的结点
		InThread(p->rchild, pre); //递归，线索化右子树
	}//if(p!=NULL)
}
//中序线索化二叉树T
void CreateInThread(ThreadTree T) {
	ThreadTree pre = NULL;
	if (T != NULL) {        //非空二叉树，线索化
		InThread(T, pre);   //线索化二叉树
		pre->rchild = NULL; //处理遍历的最后一个结点
		pre->rtag = 1;
	}
}
  • 先序线索化
//先序遍历二叉树，一边遍历一边线索化
void PreThread(ThreadTree T) {
	if (T != NULL) {
		visit(T);          //先处理根节点
	    if (T->ltag == 0)  //lchild不是前驱线索，避免爱的魔力转圈圈
		    PreThread(T->lchild);
		PreThread(T->rchild);
	}
}
void visit(ThreadNode *q) {
	if (q->lchild == NULL) {//左子树为空，建立前驱线索
		q->lchild = pre;
		q->ltag = 1;
	}
	if (pre != NULL && pre - > rchild == NULL) {
		pre->rchild = q; //建立前驱结 点的后继线索
		pre->rtag = 1;
	}
	pre = q;
}

//全局变量pre,指向当前访问结点的前驱
ThreadNode *pre = NULL;

//先序线索化（王道版）
void PreThread(ThreadTree p, ThreadTree &pre) {
	if (p != NULL) {
		if (p->lchild == NULL) { //左子树为空，建立前驱线索
			p->lchild = pre;
			p->ltag = 1;
		}
	if (pre != NULL && pre->rchild == NULL) {
		pre->rchild = p;  //建立前驱结点的后继线索
		pre->rtag = 1; .
		pre = p;   //标记当前结点成为刚刚访问过的结点
		if (p->ltag == 0)
			InThread(p->lchild, pre); //递归，线索化左子树
		InThread(p->rchild, pre);     //递归，线索化右子树
	}//if(p!=NULL)
}

//先序线索化二叉树T
void CreatePreThread(ThreadTree T) {
	ThreadTree pre = NULL;
	if (T != NULL) {
		//非空二叉树，线索化
		PreThread(T, pre);
		//线索化二叉树
		if (pre->rchild == NULL) //处理遍历的最后一 个结点
			pre->rtag = 1;
	}
}
  • 后序线索化
//全局变量pre,指向当前访问结点的前驱
ThreadNode *pre = NULL;

//后序线索化二叉树T
void CreatePostThread(ThreadTree T) {
	pre = NULL;       //pre初始为NULL
	if (T != NULL) {  //非空二叉树才能线索化
		InThread(T);  //中序线索化二叉树
		if (pre->rchild == NULL)
			pre->rtag = 1; //处理遍历的最后一个结点
	}
}

//后遍历二叉树，一边遍历一边线索化
void PostThread(ThreadTree T) {
	if (T!= NULL) {
		PostThread(T->lchild);  //后序遍历左子树
		PostThread(T->rchild);  //后序遍历右子树
		visit(T);  //访问根节点
	}
}
void visit(ThreadNode *q) {
	if (q->lchild == NULL) { //左子树为空，建立前驱线索
		q->lchild = pre;
		q->ltag = 1;
	}
	if (pre != NULL && pre->rchild == NULL) {
		pre->rchild = q;  //建立前驱结点的后继线索
		pre->rtag = 1;
	}
	pre = q;
}

//后序线索化（王道版）
void PostThread(ThreadTree p, ThreadTree &pre) {
	if (p != NULL) {
		InThread(p->lchild, pre);   //递归，线索化左子树
		InThread(p->rchild, pre);	//递归，线索化右子树
		if (p->lchild == NULL) {	//左子树为空，建立前驱线索
			p->lchild = pre;
			p->ltag = 1; .
		}
		if (pre!= NULL && pre->rchild == NULL) {
			pre->rchild = p; //建立前驱结点的后继线索
			pre->rtag = 1;
		}
		pre = p;  //标记当前结点成为刚刚访问过的结点
	} //if(p!=NULL)
}

//后序线索化二叉树T
void CreatePostThread(ThreadTree T) {
	ThreadTree pre = NULL;
	if (T != NULL) {        //非空二叉树，线索化
		PostThread(T, pre); //线索化二叉树
		if (pre->rchild == NULL) //处理遍历的最后一 个结点
			pre->rtag = 1;
	}
}
  • 中序遍历的后继结点和前驱结点
// 找到以p为根的子树中，第一个被中序遍历的结点 
ThreadNode* FirstNode(ThreadNode *p) 
{
	while(0 == p->ltag){ // 循环找到最左下结点 
		p = p->lchild;
	}
	return p;
}
// 中序线索二叉树中找到结点p的后继结点 
ThreadNode *NextNode(ThreadNode *p) 
{
	if(0 == p->rtag){
		// 返回右子树中的最左下结点 
		return FirstNode(p->rchild);
	}
	else{
		return p->rchild; // rtag == 1 直接返回后继线索 
	}
}
// 对中序线索二叉树进行中序遍历（非递归算法） 
void InOrder(ThreadNode *T) 
{
	for(ThreadNode *p = FirstNode(T); p != NULL; p = NextNode(p)){
		PrintNode(p);
	}
}



// 找到以p为根的子树中，最后一个被中序遍历的点 
ThreadNode* LastNode(ThreadNode *p)
{   
    // 循环找到最右下结点（不一定是叶节点） 
	while(0 == p->rtag){
		p = p->rchild;
	}
	return p; 
}
// 在中序线索二叉树中找到p的前驱 
ThreadNode* PreNode(ThreadNode *p)
{ 
	if(p->ltag == 0){  // 返回左子树中最右下结点 
		return LastNode(p->lchild);
	}
	else{
		return p->lchild;
	}
}
// 对线索二叉树逆向中序遍历 
void RevInOrder(ThreadNode *T)
{
	for(ThreadNode *p = LastNode(T); p != NULL; p = PreNode(p)){
		PrintNode(p);
	}
}
Thorold's Deer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树与二叉树的转换及二叉树的遍历 课程设计说明书 附代码
08-22
树与二叉树的转换及二叉树的遍历 课程设计说明书，附带详细代码，经过网上的说明书改编，补充一部分详细代码，c++编写，DEV-C++测试完全可以运行。
数据结构详解
MLLiJaiTu的博客
07-24 256
文章目录线性表线性表的顺序表示线性表的链式表示栈 (stack)栈的顺序存储栈的链式存储结构应用队列(Queue)循环队列（判满）队列的链式存储结构双端队列串树计算机科学中的树二叉查找树笛卡尔树AVL树红黑树B树（B-）B+ 树算法冒泡排序选择排序插入排序希尔排序归并排序快速排序基数排序堆排序参考链接 线性表 线性表的顺序表示 静态分配 #define MaxSize 10 // 定义最大长度 typedef struct { int data[MaxSize]; // ElemType = int,
数据结构复习：二叉树的链式存储实现
rj2017211811的博客
07-29 228
二叉树的链式存储
数据结构复习（五）——树和二叉树
wings的博客
12-18 688
树和二叉树
5.2_3_二叉树的存储结构
猫宁的博客
07-06 171
顺序存储 只能是完全二叉树的顺序来存储，实现逻辑关系 如果不是完全二叉树，按照完全二叉树一一对应起来，需要设置一位Empty来判断是否有数据 i的左子树2i i的右子树2i+1 结点为i的结点，父节点为i/2向下取整 链式存储 struct ElemType{ int value; }; typedef struct BiTNode{ ElemType data; struct BiTNode *lchild,*rchlid; }BiTNode,*BiTree; BiTree root =..
数据结构之二叉树的C++实现源码
02-15
本文件为用C++实现二叉树的源码，对于刚接触二叉树学习的同学会有一定的帮助。我是觉得，如果我的知识能给急于补充的你带来帮助，将会是我最大的乐趣。
二叉树C++源代码，模板实现，可用于各种类型
12-04
二叉树C++源代码，模板用得非常巧妙，可用于各种类型。
二叉树创建与遍历的实验程序
04-24
建立二叉树并遍历的程序，可以实现现需输入二叉树，进行先序、中序、后序遍历，同时通过树控件输出二叉树。
算法：《剑指提供》，《程序员代码面试指南》，Leetcode等算法衔接集合。基于.net core的控制台程序，C＃实现，包含每道译文的完整描述，多种解法AC代码，以及解主题算法，所有回归正确直接运行以查看输出结果。常用算法汇总中每个算法同样有测试用例，可运行
02-02
无法重置的表示还尚待补充剑指优惠排序算法经典算法Leetcode螺旋矩阵螺旋矩阵II合并两个有序时序反转链表两数相加合并两个有序链表合并K个排序链表旋转链表环形链表环形链表II相交链表删除链表中的例程整体反转回文...
二叉树链式存储
Recursions的博客
09-13 178
struct ElemType{ int value; }; typedef struct BiTNode{ ElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTree root = NULL; root = (BiTree) malloc(sizeof(BiTNode)); root -> data = {1}; root -> lchild = NULL; root ->.
二叉树基本代码实现
m0_61548909的博客
03-30 4256
目录 1.二叉树的链式结构 2.二叉树的遍历 2.1先序遍历 2.2中序遍历 2.3后序遍历 3.二叉树的基本操作 3.1求二叉树结点个数 3.1.1全局遍历 3.1.2递归的思想分治 3.1.3局部变量 3.2求二叉树叶子结点个数 3.3求二叉树第K层结点个数 3.4求二叉树的深度/高度 3.5查找二叉树中值为x的结点 3.6二叉树的销毁 3.7运用队列实现广度优先的层序遍历 1.二叉树的链式结构 typedef int BTDataType; typ
数据结构之二叉树（C语言附详细代码）
热门推荐
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
二叉树系列的代码
如月之恒，如日之升
09-07 684
代码随想录笔记
数据结构-二叉树的代码实现（详解）
最新发布
weixin_73142957的博客
07-11 2791
内容：二叉树的前、中，后序遍历，层序遍历，二叉树节点个数，叶子节点个数，二叉树高度，第k层节点的个数，查找某个节点，二叉树销毁，判断是否为完全二叉树
二叉树全部代码了解
weixin_54107527的博客
11-19 1740
带你了解二叉树全部代码（先中后序遍历，叶子个数，节点个数，深度） #include<stdio.h> #include<malloc.h> #define MAX 100 int count=0; typedef struct tnode{ char data; struct tnode *lchild,*rchild; }BT; BT *CreateBTree(){ BT *t; char ch; scanf("%c",&ch); getchar(); if
【数据结构】二叉树（C语言实现）
在平淡的日子里寻找存在的价值
08-15 6046
树和二叉树的基本介绍，以及基于C语言的链式二叉树的实现。
c++二叉树详解（附基本操作代码版）
Yoyo的博客
07-10 4420
二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。char data;}BT;// 根据输入二点中序表达式和前序表达式创建一颗二叉树// 展示一颗二叉树，以A(B, C(D, E))这样加了括号的前序遍历来实现// 销毁二叉树// 判断这颗树是不是完全二叉树// 计算树的高度// 计算叶子的数量// 计算树的宽度// 层次遍历// 前序遍历// 中序遍历// 后序遍历。
二叉树——二叉树代码，你想要的都在这里
哦豁果奶的博客
11-23 939
本篇文章仅给出关于二叉树的部分代码，若想深入了解二叉树请查看我的其他文章因为本次实验二叉树考察的内容太多了，所以我把它拆分成了三个部分，分别是建立，处理，遍历三个板块，三篇文章可以在我的博客或专栏中找到。以下是链接二叉树递归总头文件：建立二叉树结构，二叉树的三种建立。遍历按层次非递归遍历、先序非递归、先中后序递归遍历二叉树的链表结构处理求二叉树的高度、叶节点数、单分支节点数、双分支节点数，交换左右子树目录。
以二叉链表作为二叉树的存储结构。编写递归算法，计算二叉树中叶子结点的数目。请将下面的代码补充完整。
06-01
// 递归计算左子树和右子树的叶子结点数目之和 } int main() { printf("请输入二叉树的节点数据（-1表示该节点为空）：\n"); TreeNode *root = create_tree(); printf("二叉树中叶子结点数目为：%d\n", count_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值