创建二叉树及二叉树三种遍历(中)

最新推荐文章于 2023-11-25 23:36:43 发布
最新推荐文章于 2023-11-25 23:36:43 发布
阅读量213 收藏
点赞数
分类专栏： # C数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43541094/article/details/107912892
版权

准备工作一览

完成了一些必要的工具后，接下来考虑二叉树的创建，这里采用自动状态变迁图的方法的完成对二叉树表达式的判断

1- 自动状态变迁图的简介

当由用户从键盘使用gets()函数输入一个字符串时，用来判断该字符串是否合理，且进行必要的操作，如 判断一个包含（ ）+ - * / ， 字符 数字的多项式是否输入合理，并且对其计算结果，或在生成二叉树时也需要自动状态变迁图辅助，这里只讨论对一个二叉树表达式的输入是否合理进行判断

2- 自动状态变迁图的原理

先思考并画出可能存在的所有状态，使用循环，一个个的处理字符，对于每个字符进行判断，且进行它所对应的下一状态，进行相应的操作，再处理下一个字符

3- 根据一颗二叉树画出其自动状态变迁图

规定：采用先根序输入的规则，使用 ( 和 ) 来分隔结点，使用 , 来区分左右孩子，用户从键盘输入一个字符串，包含字母，括号，逗号，程序判断该字符串是否合理（不合理状况：字母连续出现，右括号在前无左括号，括号不匹配，空格被计入有效字符，连续逗号无法区分左右孩子）

先根序规则：根（左子树）（右子树）
先根序：A B D F G J L K C E H I
输入示例：A ( B ( D ( F , G ) , J ( , L ( K ) ) ) , C ( E ( H , I ) ) )

在这里插入图片描述

分析表达式后，得到的自动状态变迁图如下：

在这里插入图片描述

4- 完成判断字符串的代码

//定义类型，处理状态，定义函数
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>

#define NUMBER_STATUS_START 1
#define NUMBER_STATUS_ROOT  2 //根
#define NUMBER_STATUS_TREE  3 //子树
#define NUMBER_STATUS_DATA  4 //数据
#define NUMBER_STATUS_DOT   5 //逗号
#define NUMBER_STATUS_END   6
#define NUMBER_STATUS_RIGHT_KUOHAO  7 //右括号


typedef unsigned char boolean;

#define TRUE 1
#define FALSE 0


typedef struct NUMBER_ARG{
	int index;
	boolean ok;
	boolean finished
	int status;
}NUMBER_ARG;


boolean dealTheStr(char *str);

void dealTheStatusStart(char ch, NUMBER_ARG *arg);
void dealTheStatusROOT(char ch, NUMBER_ARG *arg);
void dealTheStatusTree(char ch, NUMBER_ARG *arg);
void dealTheStatusData(char ch, NUMBER_ARG *arg);
void dealTheStatusDot(char ch, NUMBER_ARG *arg);
void dealTheStatusRightKuoHao(char ch, NUMBER_ARG *arg);
void dealTheStatusEnd(char ch, NUMBER_ARG *arg);

boolean isData(char ch);
boolean isDot(char ch);
boolean isLeftKuoHao(char ch);
boolean isRightKuoHao(char ch);
boolean isOver(char ch);


//对每个字符的单独判断
boolean isOver(char ch) {
	if(ch == '0') {
		return TRUE;
	}else {
		;
	}
}

boolean isRightKuoHao(char ch) {
	if(ch == ')') {
		return TRUE;
	}else {
		return FALSE;
	}
}

boolean isLeftKuoHao(char ch) {
	if(ch == '(') {
		return TRUE;
	}else {
		return FALSE;
	}
}

boolean isDot(char ch) {
	if(ch == ',') {
		return TRUE;
	}else {
		return FALSE;
	}
}

boolean isData(char ch) {
	if(ch == 'A' || ch == 'B' || ch == 'C' || ch == 'D' || ch == 'E' ||
	   ch == 'F' || ch == 'G' || ch == 'H' || ch == 'I' || ch == 'J' ||
	   ch == 'K' || ch == 'L' || ch == 'M' || ch == 'O' || ch == 'N' ||
	   ch == 'P' || ch == 'Q' || ch == 'R' || ch == 'S' || ch == 'T' ||
	   ch == 'U' || ch == 'V' || ch == 'W' || ch == 'X' || ch == 'Y' || ch == 'Z') {
		return TRUE;
	}else {
		return FALSE;
	}
}

//对各种字符判断后转入相对的状态，并进行必要的操作
void dealTheStatusEnd(char ch, NUMBER_ARG *arg) {

	arg->finished = TRUE;

}

void dealTheStatusRightKuoHao(char ch, NUMBER_ARG *arg){
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_RIGHT_KUOHAO;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_DOT;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}

void dealTheStatusDot(char ch, NUMBER_ARG *arg) {
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_DATA;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_RIGHT_KUOHAO;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}

void dealTheStatusData(char ch, NUMBER_ARG *arg){
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_TREE;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_RIGHT_KUOHAO;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_DOT;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}



void dealTheStatusTree(char ch, NUMBER_ARG *arg) {
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_DATA;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_DOT;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}

void dealTheStatusROOT(char ch, NUMBER_ARG *arg) {
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_TREE;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;	
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}

void dealTheStatusStart(char ch, NUMBER_ARG *arg) {
	if(isData(ch)) {
		arg->status = NUMBER_STATUS_ROOT;
		arg->ok = TRUE;
		arg->finished = FALSE;
		arg->index++;
		//TODO 必要操作
	}else if(isLeftKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isRightKuoHao(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isDot(ch)) {
		arg->status = NUMBER_STATUS_END;
		arg->ok = FALSE;
		arg->finished = TRUE;
	}else if(isOver(ch)) {
		arg->finished = TRUE;
	}
}

//处理字符串的函数
boolean dealTheStr(char *str) {

	NUMBER_ARG arg = {  //移动下标，判断本次输入是否合法
		0,              //判断循环是否结束， 判断当前字符状态
		TRUE,
		FALSE,
		NUMBER_STATUS_START,
	};

	char ch;

	while(arg.ok && !arg.finished) {

		ch = str[arg.index];

		if(NUMBER_STATUS_START == arg.status) {
			dealTheStatusStart(ch, &arg);
		}else if(NUMBER_STATUS_ROOT == arg.status) {
			dealTheStatusROOT(ch, &arg);
		}else if(NUMBER_STATUS_TREE == arg.status) {
			dealTheStatusTree(ch, &arg);
		}else if(NUMBER_STATUS_DATA == arg.status) {
			dealTheStatusData(ch, &arg);
		}else if(NUMBER_STATUS_DOT == arg.status) {
			dealTheStatusDot(ch, &arg);
		}else if(NUMBER_STATUS_RIGHT_KUOHAO == arg.status) {
			dealTheStatusRightKuoHao(ch, &arg);
		}else if(NUMBER_STATUS_END == arg.status) {
		    dealTheStatusEnd(ch, &arg);
		}
	}

	return arg.ok;
}


int main(int argc, char const *argv[]) {

	char str[80] = {0};
	
	printf("请输入一个二叉树表达式,末尾加‘0’结束输入\n");
	gets(str);
	_flushall();

	if(TRUE == dealTheStr(str)) {
		printf("合法的二叉树表达式\n");
	}else {
		printf("非法的二叉树表达式\n");
	}

	return 0;
}

在这里插入图片描述

根据这个框架，接下来完成二叉树的创建和遍历

雫#1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树（一）：二叉树的创建以及三种遍历方法的递归实现
YANG
09-27 1万+
我们都知道现实生活中的树长什么样，那么，很明显，二叉树就是一棵“树”，不过它是一个存储数据的一种结构，根在上，向下生长。 当然，这样的存储结构只是其中的一种。在这里，就要引出二叉树的存储和二叉树的遍历了！ 树：n（n>=0）个结点的有限集合，n=0时为空树。 二叉树的三种遍历方式
二叉树创建及遍历
yingmu__的博客
12-30 1065
1. 二分搜索树 2. 平衡二叉树(最大深度和最小深度差为1)：AVL树，红黑树 3. 完全二叉树(二叉堆)：除了最高层以外，其余层节点个数都达到最大值，并且最高层节点都优先集中在最左边。 4. 满二叉树： 除了最高层有叶子节点，其余层无叶子，并且非叶子节点都有2个子节点。 5. 堆，并查集：对数据进行特殊的操作产生高效的结果 6. 线段树，Trie(字典树，前缀树) 。 二分搜索树 二分搜索树是...
java二叉树
代码如浪女,不想被她蹂躏，就得随心所欲的蹂躏她!
09-28 508
目录：  1.把一个数组的值赋值给一颗二叉树  2.具体代码  1.树的构建方法  2.具体代码  Java代码   package tree;      import java.util.LinkedList;   import java.util.List;      /**   * 功能：把一个数组的值存入二叉树中，
二叉树的建立以及三种遍历方式
heyiting666的博客
06-12 419
二叉树的建立，然后用三种方法遍历。
创建二叉树及二叉树三种遍历(上)
weixin_43541094的博客
08-10 170
准备工作一览 为了创建一颗二叉树，需要使用到自动状态变迁图和堆栈等，详细需要： (1)，定义基本类型和的mec.h和包含mec.h的跳过空格的mec.c (2)，定义显示错误的error.h和具体显示错误函数的error.c (3)，定义堆栈结构定义处理堆栈函数的stack.h和具体操作堆栈的stack.c 准备工作1- mec.c 和mec.h的创建 //mec.h头文件 #ifndef _MEC_H_ #define _MEC_H_ typedef unsigned char boolean;
二叉树的创建以及三种遍历
qq_45635939的博客
05-11 219
二叉树的创建以及三种遍历操作 c++实现 // An highlighted block #include<iostream> using namespace std; class Node { public: int value; Node*left; Node*right; Node(int v) { value=v; left=NULL; right=NULL; } }; 先序遍历 // An
二叉树的创建、（七种）遍历
yx20130919的博客
08-08 498
这一篇博客主要总结一下二叉树的创建、遍历以及整个流程。 会对二叉树的遍历进行总结，二叉树可是有七种（三大类）遍历方式的！ 科普： 树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。 二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先...
基于Java实现的二叉树的创建以及三种遍历.zip
11-14
本资料包主要探讨了如何在Java中创建二叉树以及其三种基本遍历方法：前序遍历、中序遍历和后序遍历。首先，我们需要理解二叉树节点的定义，它通常包含一个数据字段和两个指向子节点的引用。 1. **二叉树节点定义**...
java代码实例-二叉树的创建以及三种遍历（超详细）.rar
最新发布
05-20
java代码实例-二叉树的创建以及三种遍历（超详细） 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树的创建以及三种遍历方式
WALL.E
06-16 396
二叉树的创建 : TreeNode: public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } BitTree import java.ut...
数据结构：二叉树的建立，及三种遍历的实现
qq_52119136的博客
08-27 312
复习数据结构！！！
创建二叉树及二叉树三种遍历(下)
weixin_43541094的博客
08-10 291
准备工作一览 有了必要的工具后和框架后，需要仔细考虑二叉树创建的过程，将其转化为代码，写入修改好的框架中 1- 分析创建二叉树的具体过程 下面的部分参考代码，栈操作重复步骤就能得到先根序的二叉树 2- 由字符串创建先根序二叉树 bTree.h文件： #ifndef _MEC_BINATRY_TREE_H_ #define _MEC_BINATRY_TREE_H_ typedef struct B_TREE { int data; struct B_TREE *left; struct B_TRE
实验三 二叉树的基本操作（建立）及遍历
weixin_34006468的博客
11-02 1237
实验三 二叉树的基本操作（建立）及遍历 实验目的 1．学会实现二叉树结点结构和对二叉树的基本操作。 2．通过对二叉树遍历操作的实现，理解二叉树各种操作，学会利用递归方法编写对二叉树等类似递归数据结构进行处理的算法。 实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 实验内...
二叉树的建立以及三种遍历
2303_77618894的博客
11-25 540
NULL) //先序遍历。int creat(tree root)//建立二叉树。typedef struct Node//建立节点。void pop(tree root)//后序遍历。void in(tree root)//中序遍历。
建一棵二叉树,能够输入树的各个结点，并能够输出用不同方法遍历的遍历序列；分别建立二叉树存储结构的的输入函数、输出层序遍历序列的函数、输出先序遍历序列的函数...
weixin_30436101的博客
04-13 1115
using System; using System.Collections.Generic; using System.Text; using Queue; namespace Tree { //二叉树的二叉链表的结点类的实现如下所示 public class Node<T> { private T data; ...
二叉树的创建及三种遍历方式详解
小小城御园的博客
11-25 442
创建一个如下图所示的二叉树 程序如下： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; //定义二叉树 typedef struct _tree_node { char date; struct tree_node *lchild;//左节点 struct tree_node *rchild;//右节点 }tre...
写一个创建二叉树和实现二叉树三种遍历的代码
06-01
好的，以下是创建二叉树和实现三种遍历的代码： ```python class Node: def __init__(self, val): self.left = None self.right = None self.val = val def create_tree(arr, root, i, n): if i temp = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值