个人笔记--二叉树的链式存储与前、中、后、层序遍历

最新推荐文章于 2024-07-04 11:52:18 发布
原创 最新推荐文章于 2024-07-04 11:52:18 发布 · 400 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树

二叉树

创建树：

ABC$$DE$G$$F$$$

在这里插入图片描述

最主要的，结构体的构建

#define OK 1
#define ERROR 0
#define MAX_TREE_SIZE 100//树的初始空间大小
#define STACK_INIT_SIZE 100//栈的初始空间大小
#define STACKINCREMENT 10//增栈
typedef char TElemType;//树中存储的是字符
typedef bool Status;

typedef struct BiTNode{
	TElemType data;//数据域
	struct BiTNode *lchild ,*rchild;//指针域
}BiTNode,*BiTree;
BiTree T;

typedef BiTree SElemType;//栈里存的是指针
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

用到的栈子函数（详细了解栈点击传送）

Status InitStack(SqStack &S)//初始化栈
{
	S.base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if(!S.base) exit(OVERFLOW);
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
	return OK;
}

Status PushStack(SqStack &S,SElemType p)//入栈
{
	if(S.top-S.base>=S.stacksize)
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S.base)	exit(OVERFLOW);
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top++ = p;
	return OK;
}

Status PopStack(SqStack &S,SElemType &p)//出栈
{
	if(S.top == S.base)	return ERROR;
	p=*--S.top;
	return OK;
}

Status TopStack(SqStack &S,SElemType &p)//取栈顶元素
{
	if(S.top==S.base)
		return ERROR;
	p=*(S.top-1);
	return OK;
}

步入正题

1.创建树

Status createBiTree(BiTree &T)
{
	char ch;
	cin>>ch;//字符型数据
	if(ch=='$')
		T=NULL;//如果输入为'$'，说明该结点为空
	else
	{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		T->data=ch;//存储
		createBiTree(T->lchild);//访问该结点的左结点
		createBiTree(T->rchild);//访问该结点的右结点
	}
	return OK;
}

（输出结点的数据）//这个子函数不是写在其他函数内的，是供其他函数反复调用的 啊啊啊卡了好久

Status Print(TElemType e)
{
	printf("%c ",e);//just输出字符型变量e
	return OK;
}

2.先序遍历//递归方法

Status preTree(BiTree &T,Status(* visit)(TElemType e))
//第二个参数就是用来调用Print函数的
{
	if(T)
	{
		if(visit(T->data))//输出写在最前面，就是先序遍历
			if(preTree(T->lchild,Print))//接着访问左子树（递归）
				if(preTree(T->rchild,Print))//最后访问右子树
					return OK;
		return ERROR;
	}
	return OK;
}

3.后序遍历//递归方法

Status postTree(BiTree &T,Status(* visit)(TElemType e))
{
	if(T)
	{
		if(postTree(T->lchild,Print))
			if(postTree(T->rchild,Print))
				if(visit(T->data))//同理，输出放在最后面就是后序遍历
					return OK;
		return ERROR;
	}
	return OK;
}

4.中序遍历的递归方法就不写了，就是把输出函数放在两个递归子树中间即可。
这里说一下中序遍历的两种非递归（用栈模拟）算法：
（一）通过不断地取栈顶元素

Status inTree1(BiTree T,Status(* visit)(TElemType e))
{
	SqStack S;
	InitStack(S);//初始化一个栈S
	SElemType p;
	PushStack(S,T);//根指针入栈 
	while(S.top!=S.base)
	{
		while(TopStack(S,p) &&  p)
			PushStack(S,p->lchild);//向左走到尽头，取最后一个结点的左子树（我们知道是空的，所以下一步出栈）
		PopStack(S,p);//空指针出栈
		if(S.top!=S.base)//访问结点
		{
			PopStack(S,p);//出栈
			if(!visit(p->data))//输出该结点的数据域（此时该结点已出栈）
				return ERROR;
			PushStack(S,p->rchild);//访问该结点的右子树（若为空，则进行下一次循环时首先会出栈）
		}
	}
}//手动模拟一下就懂了

（二）通过不断地入栈出栈

Status inTree2(BiTree T,Status(* visit)(TElemType e))
{
	SqStack S;
	InitStack(S);
	SElemType p;
	p=T;
	while(p || S.top!=S.base)
	{
		if(p)
		{
			PushStack(S,p);//根指针入栈
			p=p->lchild;//遍历左子树
		}
		else
		{
			PopStack(S,p);//根指针出栈
			if(!visit(p->data))//输出根结点
				return ERROR;
			p=p->rchild;//遍历右子树
		}
	}
	return OK;
}

5.层序遍历

Status cengTree(BiTree &T,Status(* visit)(TElemType e))
{
	int i=0,j=0;//i用来访问，j用来存
	BiTree p[100];//数指针数组
	if(T)
		p[j++]=T;
	while(i<j)
	{
		visit(p[i]->data);//每访问一个结点，就把它的左右子树存进数组里
		if(p[i]->lchild)
			p[j++]=p[i]->lchild;
		if(p[i]->rchild)
			p[j++]=p[i]->rchild;
		i++;
	}
}

6.求树的深度

int DeepTree(BiTree T)
{
	int LD,RD;//LD指最远左子树深度，RD指最远右子树深度
	if(T==NULL)
		return 0;
	else
	{
		LD=DeepTree(T->lchild);//递归
		RD=DeepTree(T->rchild);
		return (LD>=RD?LD:RD)+1;//最后加上根节点那一层
	}
}

完整代码如下：

#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
#define OK 1
#define ERROR 0
#define MAX_TREE_SIZE 100
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef char TElemType;
typedef bool Status;
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild ,*rchild;
}BiTNode,*BiTree;
BiTree T;

typedef BiTree SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
	S.base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if(!S.base) exit(OVERFLOW);
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
	return OK;
}

Status PushStack(SqStack &S,SElemType p)
{
	if(S.top-S.base>=S.stacksize)
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S.base)	exit(OVERFLOW);
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top++ = p;
	return OK;
}

Status PopStack(SqStack &S,SElemType &p)
{
	if(S.top == S.base)	return ERROR;
	p=*--S.top;
	return OK;
}

Status TopStack(SqStack &S,SElemType &p)
{
	if(S.top==S.base)
		return ERROR;
	p=*(S.top-1);
	return OK;
}


Status createBiTree(BiTree &T)
{
	char ch;
	cin>>ch;
	if(ch=='$')
		T=NULL;
	else
	{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		T->data=ch;
		createBiTree(T->lchild);
		createBiTree(T->rchild);
	}
	return OK;
}

Status Print(TElemType e)
{
	printf("%c ",e);
	return OK;
}
	
Status preTree(BiTree &T,Status(* visit)(TElemType e))
{
	if(T)
	{
		if(visit(T->data))
			if(preTree(T->lchild,Print))
				if(preTree(T->rchild,Print))
					return OK;
		return ERROR;
	}
	return OK;
}

Status inTree1(BiTree &T,Status(* visit)(TElemType e))
{
	SqStack S;
	InitStack(S);
	SElemType p;
	PushStack(S,T);
	while(S.top!=S.base)
	{
		while(TopStack(S,p) &&  p)
			PushStack(S,p->lchild);
		PopStack(S,p);
		if(S.top!=S.base)
		{
			PopStack(S,p);
			if(!visit(p->data))
				return ERROR;
			PushStack(S,p->rchild);
		}
	}
}

Status inTree2(BiTree T,Status(* visit)(TElemType e))
{
	SqStack S;
	InitStack(S);
	SElemType p;
	p=T;
	while(p || S.top!=S.base)
	{
		if(p)
		{
			PushStack(S,p);
			p=p->lchild;
		}
		else
		{
			PopStack(S,p);
			if(!visit(p->data))
				return ERROR;
			p=p->rchild;
		}
	}
	return OK;
}

Status postTree(BiTree &T,Status(* visit)(TElemType e))
{
	if(T)
	{
		if(postTree(T->lchild,Print))
			if(postTree(T->rchild,Print))
				if(visit(T->data))
					return OK;
		return ERROR;
	}
	return OK;
}

Status cengTree(BiTree &T,Status(* visit)(TElemType e))
{
	int i=0,j=0;
	BiTree p[100];
	if(T)
		p[j++]=T;
	while(i<j)
	{
		visit(p[i]->data);
		if(p[i]->lchild)
			p[j++]=p[i]->lchild;
		if(p[i]->rchild)
			p[j++]=p[i]->rchild;
		i++;
	}
}

int DeepTree(BiTree T)
{
	int LD,RD;
	if(T==NULL)
		return 0;
	else
	{
		LD=DeepTree(T->lchild);
		RD=DeepTree(T->rchild);
		return (LD>=RD?LD:RD)+1;
	}
}

int main()
{
	cout<<"***********************************************"<<endl;
	cout<<"************ 1.创建二叉树      *****************"<<endl;
	cout<<"************ 2.先序遍历二叉树  *****************"<<endl;
	cout<<"************ 3.中序遍历二叉树1 *****************"<<endl;
	cout<<"************ 4.中序遍历二叉树2 *****************"<<endl;
	cout<<"************ 5.后序遍历二叉树  *****************"<<endl;
	cout<<"************ 6.层序遍历二叉树  *****************"<<endl;
	cout<<"************ 7.求二叉树的深度  *****************"<<endl;
	cout<<"************ 8.退出            ****************"<<endl;
	cout<<"***********************************************"<<endl;
	
	int n;
	do
	{
		cout<<"请输入选择：" ;
		cin>>n;
		switch(n)
		{
			case 1:
				cout<<"输入："; 
				createBiTree(T);
				cout<<"创建成功"<<endl;
				break;
			case 2:
				cout<<"前序遍历："; 
				preTree(T,Print);
				cout<<endl;
				break;
			case 3:
				cout<<"中序遍历1："; 
				inTree1(T,Print);
				cout<<endl;
				break;
			case 4:
				cout<<"中序遍历2："; 
				inTree2(T,Print);
				cout<<endl; 
				break;
			case 5:
				cout<<"后序遍历："; 
				postTree(T,Print);
				cout<<endl;
				break;
			case 6:
				cout<<"层序遍历："; 
				cengTree(T,Print);
				cout<<endl; 
				break;
			case 7:
				cout<<"该二叉树的深度是：";
				cout<<DeepTree(T)<<endl;
				break;
			default :
				cout<<"输入指令不存在"<<endl; 
				break;
		}
	}while(n!=8);
	cout<<"程序已退出，欢迎下次使用"<<endl;
	return 0;
}

I can do it.

二叉树笔记：二叉树建立、输出（使用括号）、三种遍历、层序遍历等小功能代码记录
被一个OIER遗弃的一堆烂代码
05-07 1754
数据结构与算法学习网站：http://data.biancheng.net/ 其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或多会存在空间浪费的现象。最让我感觉难的地方并不是这些函数的递归，而是建立链式存储结构时的指针，老是让人摸不着头脑，还是地址没学好????。 结构体——链式存储： typedef struct BiTNode{ TElemType data;//数据域 struct BiTNode *lchild,*rchild;//左右
【408篇】C语言笔记-第十四章（ 二叉树的建树和遍历&考研真题实战）
weixin_45842494的博客
12-13 843
树是n(n>=0)个节点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足：树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点：树的结构：二叉树是另一种树形结构，其特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。与树相似，二叉树也以递归的形式定义。二叉树是n(n>=0)个结点的有限集合：二叉树的顺序存储：二叉树的链式存储：树节点数据结构： 树中任何一个结点都是一个结构体，它的空间我们通过malloc申请。function.h m
数据结构(13)---二叉树之链式结构(前序遍历, 中序遍历, 后序遍历, 层序遍历)
李憨憨
07-23 566
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
二叉树链式存储之 前序，中序 ，后序遍历 查找
weixin_41316824的博客
03-22 573
关于二叉树顺序存储和遍历的概念可以参考 ：二叉树的顺序存储 接下来我们讲解一下二叉数的链表存储结构： 二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域，我们称这样的链表为二叉链表。 以该树为例 节点结构： 数结构： 我们当然还可以多开辟一个区域用来存放当前节点的父节点： 二叉排序树 二叉排序树，又称为二叉查找树。它或者是一棵空树，或者是具有下列...
数据结构(C语言版)——二叉树链式存储以及前序、中序、后序遍历(代码版)
qq_42683219的博客
09-30 2113
一、代码 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int Status; typedef struct node{ char data; struct node *leftChild,*rightChild; }biTreeNode,*TREEPOINTER; int printMenu(void); Status PleaseInit(void); Stat
二叉树（链表实现）--前序、中序、后序、层序遍历
一名小白的博客
07-25 4296
二叉树（链表实现）–前序、中序、后序、层序遍历 ​ 我们把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访问，我们可以把二叉树的遍历分为以下三种方式： 1.前序遍历； ​ 先访问根结点，然后再访问左子树，最后访问右子树 2.中序遍历； ​ 先访问左子树，中间访问根节点，最后访问右子树 3.后序遍历； ​ 先访问左子树，再访问右子树，最后访问根节点 如果我们分别对下面的树使用三种遍历方式进行遍历，得到的结果如下： 前序遍历 public Queu
05-5.2.2 二叉树的存储结构
G2Esports_NiKo的博客
06-15 1240
喜欢《数据结构》部分笔记的小伙伴可以订阅专栏，今后还会不断更新。🧑‍💻🚀🙏。
王道数据结构第五章树与二叉树（代码及笔记）
最新发布
Java程序员十六的博客
07-04 865
思路：从第一个元素出发，重新进行一次中序遍历，指针q记录当前访问的节点，指针pre记录上一个被访问的节点— --- — 当q == p时，pre为前驱（p为所找元素）4.若删除节点有左子树和右子树，则让左子树最右侧的节点代替自己，然后删除左子树最右侧的节点(让右子树最左侧的节点代替自己，然后删除右子树最右侧的节点)③按层序从1开始，节点i的左孩子为2i，右孩子为2i+1，父节点为。③按层序从1开始，节点i的左孩子为2i，右孩子为2i+1，父节点为。
数据结构笔记——树与二叉树
pythonxxoo的博客
04-07 1207
Python微信订餐小程序课程视频 https://edu.youkuaiyun.com/course/detail/36074 Python实战量化交易理财系统 https://edu.youkuaiyun.com/course/detail/35475 好好学习，天天向上 本文已收录至我的Github仓库DayDayUP：github.com/RobodLee/DayDayUP，欢迎Star ⭐⭐⭐⭐⭐转载请注明出处：https://blog.youkuaiyun.com/weixin_43461520/article/details/
数据结构-链式二叉树（前序遍历-中序遍历-后续遍历-层序遍历）
weixin_40593924的博客
11-06 1261
数据结构-链式二叉树 1、前言 2、n遍历 （1）前序遍历 它是树结构插入、删除、修改、查找和排序运算的前提，是二叉树一切运算的基础和核心。 遍历二叉树----从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点均被访问一次且仅被访问一次。 前序遍历的操作意义 心法口诀：根 - 左 - 右 （2）中序遍历 （3）后序遍历 （4）层序遍历 总...
【树】建立二叉链表存储的二叉树+遍历二叉树(先序、中序、后序、层序)
weixin_51424157的博客
01-10 2万+
二叉树的先序构建和先序遍历算法 1.建立二叉链表存储的二叉树 1-1.原理 二叉树的构建利用了递归的原理，在按先序序列构建二叉树时，为了能让电脑知道每个结点是否有左右孩子，我们要对原二叉树进行扩展，明确表示每个结点的左右孩子，若当前结点没有左右孩子，我们用’#'表示。 由普通二叉树---->扩展二叉树，如下图： 此时当我们按先序序列构建上面的二叉树时，应输入的序列为：AB#D##C## 1-2.代码 void CreateBiTree(BiTree *T) // 二叉树的构造 { char
二叉树的链式结构的实现
想要上进的coder的博客
12-05 1995
一、手动创建一颗树
用二叉链表存储的二叉树进行先序、中序和后序遍历的算法
热门推荐
分享不仅为了他人，同时也为了自己
10-12 4万+
用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作 #include #include #include using namespace std; typedef int Elemtype; typedef struct BiTnode { Elemtype dat
二叉树链式存储及前序遍历
Dean_Deng的专栏
03-22 1698
代码实现二叉树配图： #include #include typedef char DataType; typedef struct Node {     DataType data;     struct Node *leftChild;     struct Node *rightChild; }BiTreeNode; /*初始化创建二叉树的头结点*/ voi
02二叉树链式结构实现_BiTreeLink
AKK188888881的博客
10-06 212
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ /*
二叉树链式存储及二叉树各种遍历的算法实现
onlyone__的博客
09-25 2357
二叉树链式存储及二叉树各种遍历的算法实现 书是一种一对多的逻辑结构，在使用链式存储的时候，经常使用的是二叉链表（三个域：左孩子指针域，数据域，右孩子指针域），三叉链表（左孩子域，数据域，双亲域，右孩子域），这里使用的是二叉链表完成了几个最基本的二叉树的操作。 #include <iostream> using namespace std; typedef struct BiTNode { char data; struct BiTNode *lchild, *rchild; }BiTNo
数据结构与性质(2)栈(stack)基础板子
weixin_63714970的博客
01-10 749
数据结构与性质(2)栈(stack)基础板子
C语言数据结构笔记与源码详解
二叉树的遍历方式包括前序、中序、后序三种深度优先遍历，以及层序遍历（广度优先）。这些遍历算法既可以使用递归实现，也可以借助栈或队列进行非递归实现。在C语言中，通常用结构体定义树节点，包含数据域和两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值