二叉树的创建和遍历（二叉树基本操作及四种遍历方式）

最新推荐文章于 2023-05-03 21:50:03 发布
最新推荐文章于 2023-05-03 21:50:03 发布
阅读量2.8k 收藏 31
点赞数 3
文章标签： 算法 数据结构 霍夫曼树 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JackCorleone/article/details/122547303
版权

1、采用书上第 127 页定义的二叉树的二叉链表存储表示，编写递归算法实现二叉树的下列基本操作。
（1）构造二叉树 （2）复制二叉树 （3）销毁二叉树 （4）先序遍历二叉树 
（5）中序遍历二叉树 （6）后序遍历二叉树 （7）求二叉树的深度 （8）求二叉树的结点数 
（9）求二叉树的叶子结点数 （10）交换二叉树的左右子树
2、采用书上第 127 页定义的二叉树的二叉链表存储表示，编写非递归算法实现二叉树的下列基本操作。
（1）构造二叉树 （2）先序遍历二叉树 （3）中序遍历二叉树 
（4）后序遍历二叉树 

例题一：

#include <stdio.h>
#include <stdlib.h>
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef  char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode,*BiTree;
int Nodenum = 0;
int  Count = 0;
Status CreateBiTree(BiTree& T) {
	char ch;
	scanf("%c", &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 PreOrderTraverse(BiTree T) {
	if (T) {
		printf("%c", T->data);
		if (PreOrderTraverse(T->lchild))
			if (PreOrderTraverse(T->rchild))return OK;
		return ERROR;
	}
	else return OK;
}
Status InOrderTraverse(BiTree T) {
	int m = 0;
	if (T) {
		if (InOrderTraverse(T->lchild))m = 1;
		printf("%c", T->data);
		if (m)
			if (InOrderTraverse(T->rchild))return OK;
		return ERROR;
	}
	else return OK;
}
Status PostOrderTraverse(BiTree T) {
	if (T) {
		if (PostOrderTraverse(T->lchild))
			if (PostOrderTraverse(T->rchild)) {
				printf("%c", T->data); return OK;
			}
		return ERROR;
	}
	else return OK;
}
int Depth(BiTree T)
{
	int leftDepth, rightDepth;
	if (T == NULL)return 0;
	else {
		leftDepth = Depth(T->lchild);
		rightDepth = Depth(T->rchild);
		if (leftDepth >= rightDepth)return leftDepth + 1;
		else return rightDepth + 1;
	}
}
Status NodeCount(BiTree T) {
	if (T) {
		Nodenum++;
		if (NodeCount(T->lchild))
			if (NodeCount(T->rchild))return OK;
		return ERROR;
	}
	else return OK;
}
Status LeafCount(BiTree T) {
	if (T) {
		if (T->lchild == NULL && T->rchild == NULL) {
			printf("%c", T->data); Count++;
		}
		if (LeafCount(T->lchild))
			if (LeafCount(T->rchild))return OK;
		return ERROR;
	}
	else return OK;
}
Status ExchangeBiTree(BiTree& T) {
	BiTree p;
	if (T) {
		if (T->lchild || T->rchild) {
			p = T->lchild; T->lchild = T->rchild; T->rchild = p;
		}
		if (ExchangeBiTree(T->lchild))
			if (ExchangeBiTree(T->rchild))return OK;
		return ERROR;
	}
	else return OK;
}
Status CopyBiTree(BiTree T, BiTree& B) {
	if (T == NULL)
		B = NULL;
	else {
		if (!(B = (BiTNode*)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		B->data = T->data;
		CopyBiTree(T->lchild, B->lchild);
		CopyBiTree(T->rchild, B->rchild);
	}
	return OK;
}
Status DestoryTree(BiTree& T) {
	if (T) {
		DestoryTree(T->lchild);
		DestoryTree(T->rchild);
		free(T);
	}
	return OK;
}
Status ClearTree(BiTree& T) {
	if (T) {
		T = NULL;
	}
	return OK;
}
int main()
{
	BiTree T, B;
	printf("创建二叉树，按先序次序输入二叉树中结点的值：\n");
	CreateBiTree(T);
	NodeCount(T);
	printf("二叉树的结点个数为：%d\n", Nodenum);
	printf("二叉树的深度为：%d\n", Depth(T));
	printf("先序遍历二叉树，结果是：\n");
	PreOrderTraverse(T);
	printf("\n");
	printf("后序遍历二叉树，结果是：\n");
	PostOrderTraverse(T);
	printf("\n");
	printf("输出二叉树的叶子结点：\n");
	LeafCount(T);
	printf("\n");
	printf("统计二叉树的叶子结点个数：%d\n", Count);
	printf("交换二叉树中所有节点的左右子树！\n");
	ExchangeBiTree(T);
	if (CopyBiTree(T, B) == OK)printf("成功复制二叉树T到二叉树B！\n");
	if (DestoryTree(T) == OK)printf("成功销毁二叉树T！\n");
	if (ClearTree(T) == OK)printf("将二叉树T置为空树！\n");
	printf("先序遍历二叉树B，结果是:\n");
	PreOrderTraverse(B);
	printf("\n");
	printf("中序遍历二叉树B，结果是：\n");
	InOrderTraverse(B);
	printf("\n");
	printf("后续遍历二叉树B，结果是：\n");
	PostOrderTraverse(B);
	printf("\n");
}

例题二：

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCERMENT 10
typedef int Status;
typedef char TElemType;
typedef int QElemType;
int Nodenum = 0;
typedef struct BiNode
{
	TElemType data;
	struct BiNode* lchild, * rchild;
}BiNode,*BiTree;
typedef struct SqStack
{
	BiTree* base;
	BiTree* top;
	int stacksize;
}SqStack;
typedef struct QNode
{
	BiTree data;
	struct QNode* next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
Status InitQueue(LinkQueue& Q)
{
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if (!Q.front)	exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)	return TRUE;
	else return FALSE;
}
Status EnQueue(LinkQueue& Q, BiTree e)
{
	QueuePtr p;
	p = (QueuePtr)malloc(sizeof(QNode));
	if (!p)	exit(OVERFLOW);
	p->data = e;	p->next = NULL;
	Q.rear->next = p;	
	Q.rear = p;
	return OK;
}
Status DeQueue(LinkQueue& Q, BiTree& e)
{
	QueuePtr p;
	if (Q.front == Q.rear)	return OK;
	p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p)	Q.front = Q.rear;
	free(p);
	return OK;
}
Status InitStack(SqStack& S)
{
	S.base = (BiTree*)malloc(STACK_INIT_SIZE * sizeof(BiTree));
	if (!S.base)	exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}
Status GetTop(SqStack& S, BiTree& T)
{
	if (S.top == S.base)	return OK;
	T = *(S.top - 1);
	return OK;
}
Status Push(SqStack& S, BiTree& T)
{
	if (S.top - S.base > S.stacksize)
	{
		if (!(S.base = (BiTree*)realloc(S.base, (S.stacksize + STACKINCERMENT) * sizeof(BiTree))))	exit(OVERFLOW);
		if (!S.base)	exit(OVERFLOW);
		S.top = S.base + STACK_INIT_SIZE;
		S.stacksize += STACKINCERMENT;
	}
	*S.top++ = T;
	return OK;
}
Status Pop(SqStack& S, BiTree& T)
{
	if (S.top == S.base)	return ERROR;
	T = *--S.top;
	return OK;
}
Status StackEmpty(SqStack& S)
{
	if (S.top == S.base)
		return TRUE;
	else
		return FALSE;
}
Status CreateBiTree(BiTree& T)
{
	BiTree p;
	struct TFlag{
		int LTag=0;
		int RTag=0;
	}Tr[600];
	SqStack Q;	InitStack(Q);
	int i = 0;
	char ch[600];
	scanf("%s", &ch);
	T = (BiTree)malloc(sizeof(BiNode));
	T->data = ch[0];
	Push(Q, T);
	int num = 1;
	while (ch[num] != '\0')
	{
		if (ch[num] == '#')
		{
			while (!StackEmpty(Q))
			{
				GetTop(Q, p);
				if (Tr[i].LTag == 0)
				{
					p->lchild = NULL;	Tr[i].LTag = 1;	break;
				}
				else if (Tr[i].RTag == 0)
				{
					p->rchild = NULL;	Tr[i].RTag = 1;	break;
				}
				else
				{
					Pop(Q, p);		Tr[i].LTag = 0;		Tr[i].RTag = 0;		i--;
				}
			}
		}
		else
		{
			BiTree m = (BiTree)malloc(sizeof(BiNode));
			m->data = ch[num];
			while (!StackEmpty(Q))
			{
				GetTop(Q, p);
				if (Tr[i].LTag == 0)
				{
					p->lchild = m;		Tr[i].LTag = 1;		break;
				}
				else if (Tr[i].RTag == 0)
				{
					p->rchild = m;		Tr[i].RTag = 1;		break;
				}
				else
				{
					Pop(Q, p);		Tr[i].LTag = 0;		Tr[i].RTag = 0;		i--;
				}
			}
			Push(Q, m);
			i++;
			Tr[i].LTag = 0;
			Tr[i].RTag = 0;
		}
		num++;
	}
	return OK;
}
int Depth(BiTree T) {
	int first = -1, last = -1, flag = 0, level = 0;
	BiTree Dueue[STACK_INIT_SIZE], Temp;
	Dueue[++last] = T; 
	while (first < last) { 
		Temp = Dueue[++first];
		if (Temp->lchild)
		{
			Dueue[++last] = Temp->lchild; 
		}
		if (Temp->rchild)
		{
			Dueue[++last] = Temp->rchild;
		}
		if (first == flag)
		{
			level++; 
			flag = last; 
		}

	}
	return level;
}
Status InOrderTraverse(BiTree T)
{
	SqStack S;	InitStack(S);	Push(S, T);		BiTree p;
	while (!StackEmpty(S))
	{
		while (GetTop(S, p) && p)	Push(S, p->lchild);
		Pop(S, p);
		if (!StackEmpty(S))
		{
			Pop(S, p);	printf("%c", p->data);
			Push(S, p->rchild);
		}
	}
	printf("\n");
	return 0;
}
Status PreOrderTraverse(BiTree T)
{
	SqStack S;	InitStack(S);	Push(S, T);		BiTree p;
	while (!StackEmpty(S))
	{
		while (GetTop(S, p) && p)	{ printf("%c", p->data);	Push(S, p->lchild); }
		Pop(S, p);
		if (!StackEmpty(S))
		{
			Pop(S, p);	
			Push(S, p->rchild);
		}
	}
	printf("\n");
	return 0;
}
Status PostOrderTraverse(BiTree T)
{
	SqStack S;	InitStack(S);	BiTree p = T, q, r=NULL;
	while (p || !StackEmpty(S))
	{
		if (p)
		{
			Push(S, p); p = p->lchild;
		}
		else
		{
			GetTop(S, q);
			if (q->rchild == NULL || q->rchild == r)
			{
				Pop(S, r);
				printf("%c", r->data);
			}
			else p = q->rchild;
		}
	}
	printf("\n");
	return 0;
}
Status	ExchangeBiTree(BiTree& T)
{
	LinkQueue Q;	InitQueue(Q);	BiTree Temp, p;
	EnQueue(Q, T);
	while (!QueueEmpty(Q))
	{
		DeQueue(Q, p);
		if (p->lchild!=NULL || p->rchild!=NULL)
		{
			Temp = p->lchild;	p->lchild = p->rchild;	p->rchild = Temp;
		}
		if (p->lchild!=NULL)	EnQueue(Q, p->lchild);
		if (p->rchild!=NULL)	EnQueue(Q, p->rchild);
	}
	return OK;
}
void levelTraverse(BiTree T)
{
	BiTree a[600];
	BiTree b[600];
	a[0] = T;	a[1] = NULL;
	b[0] = T;	b[1] = NULL;
	printf("%c", T->data);
	int num = 1;
	while (num != 0)
	{
		num = 0;
		for (int i = 0; a[i] != NULL; i++)
		{
			if (a[i]->lchild != NULL)		b[num++] = a[i]->lchild;
			if (a[i]->rchild != NULL)		b[num++] = a[i]->rchild;
			if (a[i]->lchild == NULL && a[i]->rchild == NULL)	Nodenum++;
		}
		for (int i = 0; i < num; i++)
		{
			a[i] = b[i];	printf("%c", a[i]->data);
		}
		a[num] = NULL;
	}
}
int main()
{
	BiTree T;
	printf("创建二叉树，按先序次序输入二叉树中结点的值：\n");
	CreateBiTree(T);
	printf("二叉树的深度为：%d\n", Depth(T));
	printf("先序遍历二叉树，结果是：\n");
	PreOrderTraverse(T);
	printf("中序遍历二叉树，结果是：\n");
	InOrderTraverse(T);
	printf("后序遍历二叉树，结果是：\n");
	PostOrderTraverse(T);
	printf("层序遍历二叉树，结果是：\n");
	levelTraverse(T);
	printf("统计二叉树的叶子结点的个数：%d\n",Nodenum );
	printf("交换二叉树中所有结点的左右子树！\n");
	ExchangeBiTree(T);
	printf("先序遍历二叉树，结果是：\n");
	PreOrderTraverse(T);
	printf("中序遍历二叉树，结果是：\n");
	InOrderTraverse(T);
	printf("后序遍历二叉树，结果是：\n");
	PostOrderTraverse(T);
	printf("层序遍历二叉树，结果是：\n");
	levelTraverse(T);
}

Jack.D.Heven
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的创建和遍历
zuojiejie的博客
11-29 5901
二叉树的创建可以选择顺序存储方式创建二叉树和链式存储方式创建二叉树。我们为了创建一棵完整的二叉树，需要对普通的二叉树进行拓展，如图所示：其实建立二叉树也是利用了递归的原理。只不过在原来应该是打印结点的地方，改成了生成结点，给结点赋值的操作而已。大家可以先看后面的二叉树的遍历，再来看二叉树的创建。
二叉树的建立和遍历
m0_56246173的博客
11-22 3108
在二叉树的存储中，我们发现在创建二叉树函数的时候，，它的参数是char* &str,此处的&是c++中的引用，什么是引用呢？ 格式为：类型 &引用变量名 = 已定义过的变量名。 例如：,此处的引用b便是a的重命名，怎么理解呢，其实a,b指的是同一个变量，a,b只是他不同的名字。 此处为什么用引用呢，如果去掉引用会发生什么呢？ 在数组元素等于ABC##DE##F##G#H## 的时候，输出值会发生错误，发现只在abc之间，不会遍历到后面的元素。怎么样的思路呢，我们递归调用函数时，比如A结点接下来进入左孩子调用
【数据结构】二叉树的创建和四种遍历（附带详细注释）
weixin_65334260的博客
08-01 4364
树是一种比起线性表更加复杂的存储结构，其是一种非常重要的非线性数据结构，树结构在客观世界中普遍存在，其中二叉树的运用最为广泛。本篇文章主要介绍了二叉树的链式存储结构（即二叉链表）的创建与遍历，这将为以后对二叉树的研究起到至关重要的作用。............
头歌 二叉树的二叉链表存储及基本操作
lmq886的博客
04-10 5208
【代码】头歌 二叉树的二叉链表存储及基本操作。
二叉树及遍历
moonshadow44的博客
05-24 675
二叉树的遍历一、二叉树的初始化和赋值1、定义二叉树2、引入队列3、初始化4、入栈和出栈5、用给定字符建立结点6、用给定字符创立二叉树二、四种遍历1、层次遍历2、前序遍历3、中序遍历4、后序遍历三、总代码四、测试结果 一、二叉树的初始化和赋值 1、定义二叉树 用结构体定义二叉树 typedef struct BTNode{ char element; BTNode* left; BTNode* right; }BTNode, *BTNodePtr; 2、引入队列 typedef struct BTNo
二叉树创建与遍历_二叉树创建与遍历_
09-29
二叉树的创建与遍历，使用递归调用，含前序遍历、中序遍历、后序遍历、层序遍历
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
二叉树的创建与遍历C语言实现代码.zip
最新发布
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先...
java实现二叉树的创建及5种遍历方法(总结)
08-30
下面小编就为大家带来一篇java实现二叉树的创建及5种遍历方法(总结)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
二叉树的构建与遍历
m0_74787322的博客
05-03 126
之所以可以利用递归，因为当根据前序遍历结果可知，第一位是整颗树的根节点，而根据中序遍历中找到当前这个第一位的index，在中序遍历序列中该index之前和之后的两段被切分成了两颗子树，并且根据这两颗子树的长度可以从前序的列表中切除这两颗子树的前序遍历列表，因此我们发现对于每一个节点的操作一致，且最终的终止条件为最原始的前序为空时递归结束。该类题目的策略就是通过树的前序遍历和中序遍历来创建一颗已知树，并通过创建得到的树进行层序的遍历输出。对于二叉树的遍历，有四种方式：层序输出，前序输出，中序输出，后序输出。
（数据结构）二叉树的建立与遍历
jiang5086的博客
04-30 1015
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 在学习了二叉树之后，对二叉树的概念还处于比较懵的状态，下面就一项实验报告来具体实现二叉树，目的是为了掌握二叉树的定义，并且实现二叉树的链式存储结构以及在链式存储结构中的三种遍历（前序、中序、后序）。 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是二叉树？ 二叉树（binary tree）是一个有限的结点集合，这个集合或则为空，或则由一个根结点和两颗互不相交的称为左子树（left subt.
二叉树的基本内容（创建，遍历，节点个数，深度计算）
qq_52777887的博客
03-22 5077
二叉树从创建到销毁，满满的递归！
数据结构-例题实训作业-二叉树相关
Junds0的博客
11-07 872
本关任务：以先序的方式建立二叉树后，补充代码，统计该二叉树的节点数，叶子数，满节点数，计算数的高度。本关任务：以先序的方式建立二叉树后，补充代码，完成对该二叉树的先序遍历，中序遍历和后序遍历。本关任务：以先序的方式建立二叉树后，补充代码，在二叉树中查找某节点是否存在。请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）在以下空白处补写代码，以先序方式完成二叉树的建立。在以下空白处补写代码，完成任务要求。
【数据结构】二叉树的创建和遍历（先序、中序、后序）
热门推荐
m0_63448210的博客
10-30 1万+
二叉树的创建和遍历：先序中序后序 最近一段时间学习了数据结构中二叉树的基本操作，包括二叉树的结构、二叉树的创建、递归先序中序后序遍历、非递归遍历等，想和网友一起共同交流。
二叉树创建及遍历pta
12-12
二叉树是一种常用的数据结构，它由节点...而在遍历二叉树时，可以定义一个递归函数，在访问每个节点时，先输出节点值，然后递归地遍历左右子树。可以根据具体问题的要求，选择不同的遍历方式来实现对二叉树节点的访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值