二叉树的先序中序后序递归非递归遍历，插入删除等操作

最新推荐文章于 2024-07-28 17:42:24 发布
最新推荐文章于 2024-07-28 17:42:24 发布
阅读量1.8k 收藏 6
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tenlee/article/details/41347231
版权 
/*******************************************************************************************
习题：实现二叉树的生成、先序遍历、中序遍历、后序遍历，统计二叉树的叶子结点、非叶子结点

程序中已给出二叉树生成函数CreateBiTree、先序遍历函数PreOrderTraverse和统计二叉树的叶子结点函数NonLeafCount

 基本要求(必做)：
1、将中序遍历(InOrderTraverse)、后序遍历(PostOrderTraverse)函数补充完整
2、将统计二叉树的非叶子结点函数NonLeafCount补充完整
3、程序中存在一个显著错误，请找出后改正之


选作：在程序中实现以下功能
1、求二叉树的根结点Root(T)
2、求某结点的父结点Parent(T,e)
3、求结点的左孩子LeftChild(T,e)
4、求结点的右孩子RightChild(T,e)
5、求结点的左兄弟LeftSibling(T,e)
6、求结点的右兄弟RightSibling(T,e)
7、插入孩子结点InsertChild(T,p,LR,c)
8、删除孩子结点DeleteChild(T,p,LR)


注意:
1、程序运行时，设初始输入序列为"ABC  DE G  F    "
2、本作业成绩按最后完成的功能多少评分
******************************************************************************************/


#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <stack>
#include <stdlib.h>
using namespace std;
int leaf_num;//叶子结点数目
int non_leaf_num;

typedef char TElemType;  //定义树中结点的数据域的类型为字符型
typedef struct BiTNode //树的存储结构的定义
{
	TElemType data; //结点的数据域
	struct BiTNode * lchild, *rchild; //结点的左右孩子指针
} BiTNode, *BiTree;

void CreateBiTree(BiTree & T)//按先序序列创建二叉树 "ABC  DE G  F    "
{
	TElemType ch;
	scanf("%c", &ch);

	while (ch == '\n')
	{
		scanf("%c", &ch);    //吃掉一些讨厌的回车
	}

	if (ch == ' ')
	{
		T = NULL;
	}
	else
	{
		T = (BiTNode *)malloc(sizeof(BiTNode));
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}

void PreOrderTraverse(BiTree T)  //先序遍历
{
	if (T)
	{
		printf("%c", T->data); //访问根结点
		PreOrderTraverse(T->lchild);  //先序访问左子树
		PreOrderTraverse(T->rchild);  //先序访问右子树
	}
}

void InOrderTraverse(BiTree T)//中序递归遍历
{
	if (T)
	{
		InOrderTraverse(T->lchild);  //中序访问左子树
		printf("%c", T->data);
		InOrderTraverse(T->rchild);  //中序访问右子树
	}
}
void InOrderTraverse_2(BiTree T)//中序非递归遍历
{
	stack<BiTree> S;
	BiTree p;
	S.push(T);

	while (!S.empty())
	{
		p = S.top();

		while (p)
		{
			S.push(p->lchild);
			p = p->lchild;
		}

		S.pop();

		if (!S.empty())
		{
			p = S.top();
			S.pop();

			if (p->data == ' ')
			{
				return;
			}

			printf("%c", p->data);
			S.push(p->rchild);
		}
	}
}

void PostOrderTraverse(BiTree T) //后序遍历
{
	if (T)
	{
		PostOrderTraverse(T->lchild);  //后序访问左子树
		PostOrderTraverse(T->rchild);  //后序访问右子树
		printf("%c", T->data);
	}
}

void LeafCount(BiTree T)//统计二叉树叶子结点数目
{
	if (T)
	{
		if (T->lchild == NULL && T->rchild == NULL) //判断条件：当前结点无左右孩子则该结点为叶子结点
		{
			leaf_num++;    //计算器加1
		}

		LeafCount(T->lchild);//若非叶子结点则分别统计其左、右子树
		LeafCount(T->rchild);
	}
}

void NonLeafCount(BiTree T)//统计二叉树非叶子结点数目
{
	if (T)
	{
		if (T->lchild != NULL || T->rchild != NULL) //判断条件：当前结点有右孩子则该结点为非叶子结点
		{
			non_leaf_num++;    //计算器加1
		}

		NonLeafCount(T->lchild);//若非叶子结点则分别统计其左、右子树
		NonLeafCount(T->rchild);
	}
}
void Find(char f, char e, BiTree T) //找得到了父结点就找到了一切
{
	if (!T)
	{
		printf("树为空，请先建树!\n");
		return;
	}

	BiTree par, now;
	int flag = 0; // 1 左, 2 右;

	if (T->data == e)
	{
		if (f == 'b')
		{
			printf("%c 没有父结点\n", e);
		}
		else if (f == 'c')
		{
			if (T->lchild)
			{
				printf("左孩子是 %c\n", T->lchild->data);
			}
			else
			{
				printf("%c 没有左孩子结点\n", e);
			}
		}
		else if (f == 'd')
		{
			if (T->rchild)
			{
				printf("右孩子是 %c\n", T->rchild->data);
			}
			else
			{
				printf("%c 没有右孩子结点\n", e);
			}
		}
		else if (f == 'e')
		{
			printf("%c 没有左兄弟\n", e);
		}
		else
		{
			printf("%c 没有右兄弟\n", e);
		}
		return;
	}

	stack<BiTree> S;

	while (T || !S.empty()) //先序非递归遍历
	{
		while (T)
		{
			S.push(T);

			if (T->lchild) //先判断该结点是否有左孩子结点
				if (T->lchild->data == e) //再判断左孩子结点是否和e相等
				{
					flag = 1;
					par = T;
					now = T->lchild;
					break;
				}

			if (T->rchild) //先判断该结点是否有右孩子结点
				if (T->rchild->data == e) //再判断右孩子结点是否和e相等
				{
					flag = 2;
					par = T;
					now = T->rchild;
					break;
				}

			T = T->lchild;
		}

		if (flag != 0)
		{
			break;
		}

		T = S.top();
		S.pop();
		T = T->rchild;
	}

	if (!flag)
	{
		printf("没有这个结点\n");
		return;
	}

	if (f == 'b')
	{
		printf("%c 的父结点是%c\n", e, par->data);
	}
	else if (f == 'c')
	{
		if (!now->lchild)
		{
			printf("%c 没有左孩子结点\n", e);
		}
		else
		{
			printf("%c 左孩子是 %c\n", e, now->lchild->data);
		}
	}
	else if (f == 'd')
	{
		if (!now->rchild)
		{
			printf("%c 没有右孩子结点\n", e);
		}
		else
		{
			printf("%c 右孩子是 %c\n", e, now->rchild->data);
		}
	}
	else if (f == 'e')
	{
		if (flag == 1 || !par->lchild)
		{
			printf("%c 没有左兄弟结点\n", e);
		}
		else
		{
			printf("%c 的左兄弟结点是 %c\n", e, par->lchild->data);
		}
	}
	else
	{
		if (flag == 2 || !par->rchild)
		{
			printf("%c 没有右兄弟结点\n", e);
		}
		else
		{
			printf("%c 的右兄弟结点是 %c\n", e, par->rchild->data);
		}
	}
}

void Insert(BiTree & TT) //插入树
{
	int LR;
	char p,  flag;
	BiTree now, next, C, f, T = TT;
	stack<BiTree> S;
	printf("请先建立要插入的树\n");
	CreateBiTree(C);
	f = C;
	printf("请输入p(结点),LR(左孩子右孩子0,1):\t");
	scanf(" %c%d", &p, &LR);

	while (T || !S.empty()) //先序非递归遍历
	{
		while (T)
		{
			S.push(T);

			if (T->data == p) //再判断左孩子结点是否和e相等
			{
				flag = 1;
				now = T;
				break;
			}

			T = T->lchild;
		}

		if (flag != 0)
		{
			break;
		}

		T = S.top();
		S.pop();
		T = T->rchild;
	}

	if (!flag || LR > 1)
	{
		printf("没有结点 %c 或 LR输入错误\n", p);
		return;
	}

	if (LR == 0)
	{
		next = now->lchild;
		now->lchild = C;
	}
	else
	{
		next = now->rchild;
		now->rchild = C;
	}

	while (f->rchild) //p所指结点的原有左子树或右子树成为c的右子树
	{
		f = f->rchild;
	}

	f->rchild = next;
}
void destroyBiTree(BiTree & T) //删除树
{
	if (T)
	{
		destroyBiTree(T->lchild);
		destroyBiTree(T->rchild);
		free(T);
		T = NULL;
	}
}
void DelChild(BiTree & TT, char p, int LR)
{
	BiTree now, T = TT;
	int flag = 0;
	stack <BiTree> S;

	while (T || !S.empty()) //先序非递归遍历
	{
		while (T)
		{
			S.push(T);

			if (T->data == p) //再判断左孩子结点是否和e相等
			{
				flag = 1;
				now = T;
				break;
			}

			T = T->lchild;
		}

		if (flag != 0)
		{
			break;
		}

		T = S.top();
		S.pop();
		T = T->rchild;
	}

	if (!flag || LR > 1)
	{
		printf("没有结点 %c 或 LR输入错误\n", p);
		return;
	}

	if (LR == 0)
	{
		destroyBiTree(now->lchild);
	}
	else
	{
		destroyBiTree(now->rchild);
	}
}
int main()
{
	//freopen("1.txt", "r", stdin);
	BiTree bt;
	int flag = 1, LR; //用于switch语句的控制位
	char option, e, c;//用户输入字符

	/** 按先序输入二叉树序列，构造二叉树**/
	printf("构造二叉树，请按先序输入二叉树序列\n");
	CreateBiTree(bt);

	while (flag)
	{
		printf("\n请选择：\n");
		printf("1. 构造新二叉树\n");
		printf("2. 二叉树先序遍历\n");
		printf("3. 二叉树中序遍历\n");
		printf("4. 二叉树后序遍历\n");
		printf("5. 统计二叉树叶子结点数目\n");
		printf("6. 统计二叉树非叶子结点数目\n");
		printf("a、求二叉树的根结点\n");
		printf("b、求某结点的父结点Parent(T,e)\n");
		printf("c、求结点的左孩子LeftChild(T,e)\n");
		printf("d、求结点的右孩子RightChild(T,e)\n");
		printf("e、求结点的左兄弟LeftSibling(T,e)\n");
		printf("f、求结点的右兄弟RightSibling(T,e)\n");
		printf("g、插入孩子结点InsertChild(T,p,LR,c)\n");
		printf("h、删除孩子结点DeleteChild(T,p,LR)\n");
		printf("7. 退出程序\n");

		scanf(" %c", &option);
		system("cls");

		switch (option)
		{
			case '1':
				printf("请输入二叉树序列:\n");
				CreateBiTree(bt);
				break;

			case '2':
				printf("二叉树先序遍历结果:  ");
				PreOrderTraverse(bt);
				printf("\n");
				break;

			case '3':
				printf("二叉树中序递归遍历结果:   ");
				InOrderTraverse(bt);
				printf("    中序非递归遍历结果:   ");
				InOrderTraverse_2(bt);
				printf("\n");
				break;

			case '4':
				printf("二叉树后序遍历结果:   ");
				PostOrderTraverse(bt);
				printf("\n");
				break;

			case '5':
				leaf_num = 0;
				LeafCount(bt);
				printf("二叉树叶子结点数目:   %d\n", leaf_num);
				break;

			case '6':
				non_leaf_num = 0;
				NonLeafCount(bt);
				printf("二叉树叶非子结点数目:   %d\n", non_leaf_num);
				break;

			case 'a':
				printf("二叉树的根节点是:\t%c\n", bt->data);
				break;

			case 'b':
				printf("请输入该点(求父结点):\t");
				scanf(" %c", &e);
				Find(option, e, bt);
				break;

			case 'c':
				printf("请输入该点(求左孩子):\t");
				scanf(" %c", &e);
				Find(option, e, bt);
				break;

			case 'd':
				printf("请输入该点(求右孩子):\t");
				scanf(" %c", &e);
				Find(option, e, bt);
				break;

			case 'e':
				printf("请输入该点(求左兄弟):\t");
				scanf(" %c", &e);
				Find(option, e, bt);
				break;

			case 'f':
				printf("请输入该点(求右兄弟):\t");
				scanf(" %c", &e);
				Find(option, e, bt);
				break;

			case 'g':
				Insert(bt);
				break;

			case 'h':
				printf("请输入要删除的结点p的LR(0,1): ");
				scanf(" %c %d", &c, &LR);
				DelChild(bt, c, LR);
				break;

			case '7':
				flag = 0;
				printf("程序结束，按任意键退出！\n");
				break;

			default:
				{
					printf("输入错误，重新输入\n");
					break;
				}

				//
		}// end switch

		//option = getchar();
	}//end while

	return 0;
}//end

tenlee
关注
专栏目录
二叉树的三种遍历（先序中序后序）——递归非递归算法
筱羊冰冰
08-02 1139
回忆 在上一个关于树的博客提到了二叉树的三种遍历方式，还有一个单独的层次遍历。 先序、中序、后序本质山就是根、左、右的顺序问题 先序：根左右 中序：左根右 后序：左右根 递归算法 因为二叉树的定义（其实应该说树的定义）里面有递归的影子：每一个子树也要符合上述条件 （具体参见上一篇博客） 所以递归算法应该是最先想到的，而且因为递归的性质，函数形式也是最简单的。 先序： 在这里插入代码片 中序： ...
二叉树的操作——层序创建、先序、中序、后序、层序遍历
qq_54731568的博客
03-15 790
二叉树的操作——层序创建、先序、中序、后序、层序遍历
线索二叉树(中序、先序和后序及遍历)
12-21
目录链式存储线索二叉树中序线索二叉树中序线索化实现实现的代码过程中序线索二叉树的遍历遍历代码中序线索二叉树可运行代码先序线索二叉树先序线索化实现先序线索二叉树的遍历遍历代码先序线索二叉树可运行代码后序线索二叉树后序线索化实现后序线索二叉树的遍历遍历代码后序线索二叉树可运行代码 链式存储 线索二叉树是二叉树的一类，在看线索二叉树之前我们先看一下二叉树的链式存储。 原创文章 8获赞 9访问量 732 关注
先序中序后序
lazyman的专栏
04-21 5620
二叉树的遍历方法有先序中序后序三种方法，先以下图为例解释三种遍历顺序： 所谓的先后中都是以父节点为中心出发的，即 先序为：父节点、左子节点、右子节点；(父节点第一个) 中序为：左子节点、父节点、右子节点；（父节点放中间，第二个） 后序为：左子节点、右子节点、父节点；（父节点最后一个） 以上图为例， 先序遍历顺序为：GDAFEMHZ 中序遍历顺序为：ADEFGHMZ 后序遍历顺序为：AEFDHZMG 在此三种遍历顺序的基础上，已知中序和另外一种遍历即可获取第三种遍历顺序，即中序遍历+任意一种遍历顺序确定
先序中序-得后序
Tjhfsghbjknjdy的博客
12-15 196
代码： #include<stdio.h> #include<stdlib.h> #include<string.h> #define N 100 typedef struct bitnode { char data; struct bitnode *lchild,*rchild; }bitnode,*bitree; bitnode* createpr...
二叉树遍历：前序中序后序，递归非递归，层次遍历（代码）
Mr_H9527的博客
08-18 256
#include<iostream> #include<queue> #include<stack> using namespace std; typedef char elemType; #define END '#' typedef struct Node { Node* leftChild; Node* rightChild; elemType...
C语言完整代码实现二叉树的递归先序中序后序遍历以及非递归层次遍历
04-04
``` #include #include //定义二叉树结构体 struct TreeNode { int data; struct TreeNode *left; struct TreeNode *right;... printf("非递归层次遍历："); levelOrder(root); printf("\n"); return 0; } ```
Project2_二叉树_先序遍历_后序遍历_中序遍历_
10-04
二叉树的遍历是理解和操作二叉树的关键技能，其中先序遍历、中序遍历和后序遍历是最常见的三种方法。 1. **先序遍历**：先序遍历也被称为根-左-右遍历，顺序是首先访问根节点，然后递归地访问左子树，最后访问右子...
二叉树先序，中序，后序遍历非递归实现
01-28
### 二叉树先序、中序、后序遍历非递归实现 #### 一、引言 在计算机科学中，二叉树是一种常用的数据结构，它在算法设计、数据处理等方面有着广泛的应用。对于二叉树的操作，通常包括插入、删除、查找以及遍历等基本...
前序、中序、后序排列
热门推荐
flyq_coffee
10-09 1万+
1、前序遍历 先输出父结点，再左结点，最后右结点（父左右） 2、中序遍历 先输出左结点，再父结点，最后右结点（左父右） 3、后序遍历 先左结点，再右结点，最后父结点（左右父） 4、实例 前序:ABDGHICEJF 中序:GDIHBAEJCF 后序:GIHDBJEFCA ...
先序、中序、后序遍历
qianji_little_boy的博客
01-07 601
先序遍历：本身节点，左节点，右节点 思想：想实现中、左、右就需要先压入右，再压入左。 使用栈首先把头节点压入，把头节点弹出，访问；有右节点就把右节点压入，有左节点就把左节点压入；弹出就实现了中， 左， 右 代码实现： void preOrder(Node* head) { if (head == NULL) { return; } stack<Node*> st; ...
先序、中序和后序遍历
怀着坚定的梦就能走向远方
02-25 2405
初学数据结构，已经掌握了先序、中序和后序遍历的算法。 先序: 遍历顺序为"中左右" (第一个字母为根节点) 后序:遍历顺序为"左右中" (根节点在最后一个) 中序:遍历顺序为"左右中" (根节点的左边为 左子树, 右边为右子树) 理解记忆:这三种顺序,区别在于中(根)的位置,前(先)序时,中在第一个; 后序时,中在最后一个; 中序时,中在中间 (三种顺序都是左在右的前面)
二叉树前序、中序、后序遍历（递归版、非递归版）
anl_studyroad的博客
07-22 262
复习二叉树的遍历，自己实现了一遍代码，在这里进行下记录，递归和非递归都写出来了，感谢各位的批评指正。节点定义：package com.al;public class Node { public String value; public Node leftNode; public Node rightNode; public Node(String value) {
二叉树的先序、中序、后序、层序遍历方式详解，由遍历序列构造二叉树过程详解以及C++代码详细实现
weixin_45651616的博客
07-13 7854
数据结构，二叉树的先序，中序，后序，层序遍历过程详解以及C++代码详细实现；根据遍历序列构造二叉树过程详解以及C++代码详细实现。
二叉树的遍历（先序、中序、后序、层次）
最新发布
kusunoki的博客
07-28 1万+
参照王道数据结构辅导书以及哔哩哔哩大学的部分视频，对二叉树遍历的重要知识点进行归纳，并总结做题技巧。
已知先序中序求后序-已知后序中序求先序-JAVA
ZKaiji的博客
04-15 1419
通过递归遍历的方法扫描先序中序，构造二叉树； 通过递归遍历的方法扫描后序中序，构造二叉树； 方法理解起来很简单，在纸上自己画画就知道如何去做了，该算法难点在于遍历中需要精确的数学计算，还需要清晰的判断逻辑。public class BinaryTree {//内部Node类 private static class Node { private Node left; privat
先序中序转后序
点滴在心
05-03 808
#include #include using namespace std; string pre_in_to_post(string str_pre,string str_inorder,string left,string right,string &result); int main() { string str_pre,str_in,str_post; str_pre = "
先序遍历，中序遍历，后序遍历的相互求法（C语言版）
m0_73839240的博客
10-20 4468
所以在这个例子中，左子树的先序遍历结果是 2, 4, 5 ，右子树的先序遍历结果是 3。所以，这个二叉树的先序遍历结果就是：1（根节点），2（左子树的根节点），4（左子树的左子节点），5（左子树的右子节点），3（右子节点）。所以，这个二叉树的后序遍历结果就是：4（左子树的左子节点），5（左子树的右子节点），2（左子树的根节点），3（右子节点），1（根节点）。这两棵树的先序遍历都是AB，后序遍历都是BA，但它们的中序遍历分别是BA和AB，所以我们不能仅根据先序和后序遍历来确定中序遍历。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值