数据结构,二叉树遍历序列还原,c语言实现
C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历
C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历二叉树的遍历问题描述输入一棵二叉树的先序和中序遍历序列，输出其后序遍历序列。
输入输入文件为tree.in，共两行，第一行一个字符串，表示树的先序遍历，第二行一个字符串，表示树的中序遍历。
树的结点一律用小写字母表示。
输出输出文件为tree.out，仅一行，表示树的后序遍历序列。
样例输入abdecdbeac样例输出debca--------------------------------------------------------------------- --------------------------------------------------------------------- #includeusing namespace std;struct tree{char data;tree *l,*r;};tree * create(char pre[],char in[]){tree *root;if(strlen(pre)==0) {root=NULL;}else{root=new tree;root->data=pre[0];char pre1[20];pre1[0]='\0';char pre2[20];pre2[0]='\0';char in1[20];in1[0]='\0';char in2[20];in2[0]='\0';int n=1;for(int i=0;i<strlen(in);i++){< p=""> if(in[i]!=pre[0]&&n==1){in1[i]=in[i];in1[i+1]='\0';}if(in[i]==pre[0]) n=2;if(in[i]!=pre[0]&&n==2){in2[i-strlen(in1)-1]=in[i];in2[i-strlen(in1)+1]='\0';}}for(int i=1;i<strlen(pre);i++){< p=""> if(i<strlen(in1)+1){< p="">pre1[i-1]=pre[i];pre1[i]='\0';}else {pre2[i-1-strlen(pre1)]=pre[i];pre2[i-strlen(pre1)]='\0';}}root->l=create(pre1,in1);root->r=create(pre2,in2);}return root;}void post(tree * root){if(root==NULL) return; else {post(root->l);post(root->r);cout<data;}}int main(){char pre[100];char in[100];cin>>pre;cin>>in;tree * root=create(pre,in); post(root);return 0;}</strlen(in1)+1){<></strlen(pre);i++){<></strlen(in);i++){<>。
数据结构c语言课设-二叉树排序
题目:二叉排序树的实现1 内容和要求1）编程实现二叉排序树，包括生成、插入，删除；2）对二叉排序树进展先根、中根、和后根非递归遍历；3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
4）分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率，并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案：先实现二叉排序树的生成、插入、删除，编写DisplayBST函数把遍历结果用树的形状表示出来。
前中后根遍历需要用到栈的数据构造，分模块编写栈与遍历代码。
要求比照二叉排序树和数组的查找效率，首先建立一个数组存储一个班的成员信息，分别用二叉树和数组查找，利用clock〔〕函数记录查找时间来比照查找效率。
2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入，删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复！\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;if (!p->rchild) //右子树为空{q = p;p = p->lchild;free(q);}else if (!p->lchild) //左子树为空{q = p;p = p->rchild;free(q);}else{q = p;s = p->lchild;while (s->rchild){q = s;s = s->rchild;}p->data = s->data;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int 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;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{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++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号：" << a[i].key << " 姓名：" << a[i].name << " 成绩：" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。
二叉树遍历(稿)教学内容
知识拓展—利用遍历建立二叉树
输入序列： A B C D E G F
建树算法： Status CreateBiTree( BiTree &T ){ //构造二叉树T
scanf(“%c”,&ch);
If (ch==’’) T=NULL;
A
B
C
D
E
F
G
从虚线的出发点到终点的路径 上，每个结点经过3次。 第1次经过时访问，是先序遍历 第2次经过时访问，是中序遍历 第3次经过时访问，是后序遍历
2. 二叉树遍历的时间效率和空间效率 时间效率:O(n) //每个结点只访问一次 空间效率:O(n) //栈占用的最大辅助空间
精确值：树深为k的递归遍历需要k+1个辅助单元
E A
C B
G
F D
商丘工学院 信息与电子工程学院
小牛试刀
小组讨论完成
◆写出利用先序遍历创建一棵二叉树的完整算法。
个人独立完成
1、如右图所示：写出该二 叉树的前序遍历、中序 遍历和后序遍历的序列。
2、已知某二叉树的前序遍 历序列为ABDEFGC， 中序序列为DEBGFAC， 画出该二叉树。
3、已知某二叉树的后序遍 历序列为dabec，中序 序列为debac，则它的 前序遍历序列为：。
LRD
先序遍历 中序遍历
后序遍历
注：“先、中、后”的意思是指访问的结点D是先于子树出 现还是后于子树出现。
以根结点为参照系
基础知识-先序遍历
先序遍历(DLR): D
L
R
A B
A D LR
C
D LR
D
B
先序遍历序列：A B D C
c语言实现二叉树的四种遍历和求深度与叶子个数
c语言实现二叉树的四种遍历和求深度与叶子个数二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。
在C语言中，我们可以使用指针来实现二叉树的操作。
本文将介绍四种常见的二叉树遍历方式，以及如何求解二叉树的深度和叶子节点个数。
首先，我们需要定义一个二叉树节点的结构体，包含一个数据域和两个指针域，分别指向左子节点和右子节点。
代码如下：```cstruct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};```接下来，我们可以实现二叉树的四种遍历方式：前序遍历、中序遍历、后序遍历和层序遍历。
前序遍历是指先访问根节点，然后递归地遍历左子树和右子树。
代码如下：```cvoid preorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->data);preorderTraversal(root->left);preorderTraversal(root->right);}```中序遍历是指先递归地遍历左子树，然后访问根节点，最后递归地遍历右子树。
代码如下：```cvoid inorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}inorderTraversal(root->left);printf("%d ", root->data);inorderTraversal(root->right);}```后序遍历是指先递归地遍历左子树和右子树，最后访问根节点。
代码如下：```cvoid postorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}postorderTraversal(root->left);postorderTraversal(root->right);printf("%d ", root->data);}```层序遍历是按照树的层次逐层遍历节点。
《数据结构C语言》考研复习题库
《数据结构C语言》考研复习题库一、选择题1、在一个具有 n 个单元的顺序栈中，假定以地址低端（即 0 单元）作为栈底，以 top 作为栈顶指针，当做出栈处理时，top 变化为（）。
A top 不变B top ＝ 0C topD top+＋答案：C解释：在顺序栈中，出栈操作会使栈顶指针 top 减 1，即 top。
2、一个队列的入队序列是 1，2，3，4，则队列的输出序列是（）。
A 4，3，2，1B 1，2，3，4C 1，4，3，2D 3，2，4，1答案：B解释：队列是先进先出的数据结构，入队顺序为 1，2，3，4，那么出队顺序也为 1，2，3，4。
3、串是一种特殊的线性表，其特殊性体现在（）。
A 可以顺序存储B 数据元素是一个字符C 可以链式存储D 数据元素可以是多个字符答案：B解释：串的数据元素是字符，这是它与一般线性表的区别。
4、设有一个 10 阶的对称矩阵 A，采用压缩存储方式，以行序为主存储，a11 为第一元素，其存储地址为 1，每个元素占一个地址空间，则 a85 的地址为（）。
A 33B 32C 18D 40答案：A解释：对于对称矩阵，只存储其下三角或上三角部分。
对于一个 n阶对称矩阵，若以行序为主存储下三角部分，aij 的存储位置为 i(i 1)／2 ＋ j 1。
所以 a85 的地址为 8(8 1)／2 ＋ 5 1 ＝ 33。
5、一棵完全二叉树共有 700 个结点，则在该二叉树中有（）个叶子结点。
A 350B 349C 351D 不确定答案：C解释：根据完全二叉树的性质，度为 1 的结点个数最多为 1 个。
设n0 为叶子结点个数，n1 为度为 1 的结点个数，n2 为度为 2 的结点个数。
则 n ＝ n0 ＋ n1 ＋ n2 ，n 1 ＝ 2n2 ＋ n1 。
因为 n ＝ 700 ，且 n1 为 0或 1 ，通过计算可得 n0 ＝ 351 。
二、填空题1、数据的逻辑结构被分为_____、＿____、＿____和_____四种。
数据结构-C语言-树和二叉树
练习
一棵完全二叉树有5000个结点，可以计算出其
叶结点的个数是（ 2500）。
二叉树的性质和存储结构
性质4: 具有n个结点的完全二叉树的深度必为[log2n]＋1
k-1层 k层
2k−1−1＜n≤2k−1 或 2k−1≤n＜2k n k−1≤log2n＜k，因为k是整数
所以k = log2n + 1
遍历二叉树和线索二叉树
遍历定义
指按某条搜索路线遍访每个结点且不重复（又称周游）。
遍历用途
它是树结构插入、删除、修改、查找和排序运算的前提， 是二叉树一切运算的基础和核心。
遍历规则 D
先左后右
L
R
DLR LDR LRD DRL RDL RLD
遍历规则
A BC DE
先序遍历：A B D E C 中序遍历：D B E A C 后序遍历：D E B C A
练习 具有3个结点的二叉树可能有几种不同形态？普通树呢？
5种/2种
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
(a + b *(c-d)-e/f)的二叉树
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
二叉树的抽象数据类型定义
特殊形态的二叉树
只有最后一层叶子不满，且全部集中在左边
二叉树遍历（前中后序遍历，三种方式）
⼆叉树遍历（前中后序遍历，三种⽅式）⽬录刷题中碰到⼆叉树的遍历，就查找了⼆叉树遍历的⼏种思路，在此做个总结。
对应的LeetCode题⽬如下：，，，接下来以前序遍历来说明三种解法的思想，后⾯中序和后续直接给出代码。
⾸先定义⼆叉树的数据结构如下：//Definition for a binary tree node.struct TreeNode {int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};前序遍历，顺序是“根-左-右”。
使⽤递归实现：递归的思想很简单就是我们每次访问根节点后就递归访问其左节点，左节点访问结束后再递归的访问右节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;helper(root,res);return res;}void helper(TreeNode *root, vector<int> &res){res.push_back(root->val);if(root->left) helper(root->left, res);if(root->right) helper(root->right, res);}};使⽤辅助栈迭代实现：算法为：先把根节点push到辅助栈中，然后循环检测栈是否为空，若不空，则取出栈顶元素，保存值到vector中，之后由于需要想访问左⼦节点，所以我们在将根节点的⼦节点⼊栈时要先经右节点⼊栈，再将左节点⼊栈，这样出栈时就会先判断左⼦节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;stack<TreeNode*> st;st.push(root);while(!st.empty()){//将根节点出栈放⼊结果集中TreeNode *t = st.top();st.pop();res.push_back(t->val);//先⼊栈右节点，后左节点if(t->right) st.push(t->right);if(t->left) st.push(t->left);}return res;}};Morris Traversal⽅法具体的详细解释可以参考如下链接：这种解法可以实现O(N)的时间复杂度和O(1)的空间复杂度。
数据结构(C语言版CHAP6(1)
G
说明 1）二叉树中每个结点最多有两颗子树；二叉树每个结点度小于等于2; 2）左、右子树不能颠例——有序树; 3）二叉树是递归结构，在二叉树的定义中又用到了二叉树的概念;
结束
第 16 页
6.2 二 叉 树
A B D G (a) E C F F C
A B D G (b) E
(a)、(b)是不同的二叉树， (a)的左子树有四个结点， (b)的左子树有两个结点，
结束
第 17 页
6.2 二 叉 树
2． 二叉树的基本形态
φ
结束
第 18 页
6.2 二 叉 树
3．应用举例 例1 可以用二叉树表示表达式
+ a * /
e
f
b
c
d
a+b*(c-d)-e/f
结束
ห้องสมุดไป่ตู้
第 19 页
6.2 二 叉 树
例2 双人比赛的所有可能的结局
开始
甲
开局连赢两局 或五局三胜
乙
甲
甲 甲 乙
乙
对于线性结构由于每个结点只有一个直接后继，遍历是很容易的事 二叉树是非线性结构，每个结点可能有两个后继，如 何访问二叉树的每个结点，而且每个结点仅被访问一次？
结束
第 32 页
6.3
一 二叉树的遍历方法
二叉树的遍历
二叉树由根、左子树、右子树三部分组成 二叉树的遍历可以分解为：访问根，遍历左子树和遍历右子树 令：L：遍历左子树 D：访问根结点 R：遍历右子树 有六种遍历方法： DLR，LDR，LRD，
3）树的结点，可以有零个或多个后继； 4）除根外的其他结点，都存在唯一条从根到该结点的路径； 5）树是一种分枝结构
利用遍历序列还原二叉树算法的研究与实现
ｗｈｌ ｊ＋ ！ ｐｅ ｉ ｉ （（ ｍ） （ｒ＋） ｅ ｎ ＝ ． ）
ｍ ＋＋ ：
ｉ（ ｆｍ＝＝ 、 ｋ
ｐ ＞ｉ ｈ ｌ ＝ － ｃ ｉｄ ＮＵＬＬ；
ｅｓ ｌｅ
ｗｈｌ ｉ＋ ｌ ｐ ｓ ｊ） ｉ （（ ｍ） （ｏｔ ） ｅ ｎ ＝ ＋
ｍ ＋＋ ：
ｐ＞ｅ ｉ ＝ ｒｉｔｔ ｅｐｅｉ， ｌ＋ ｋｋｍ一） － ｌ ｌ ｐｅｎｏｒ （ｒ， ｉ ， ｍ－， ｈｄ ｅ ｎ＋ ｉ ， １
Ｂ ｒ Ｎｏ ｅ ｐｅ ｔｔ ｅｃ ａ ｐｅ 】 ｃ ａ ｔ ｅ ｄ ｒｉ ｏｒ （ｈ ｒ ｒ［ ， ｈｒ ｅ ｎ ｅ
树 。根 据遍 历 序 列 还 原 一 棵 二义 树 的基 本过 为 ：先还 原根 结 点 ，再还 原左子 树和 右子 树 ，可
以 由前 序或 后序 序 列确 定根 结 点 ， 然后 再利 川 中
，
ｉ（ ｆｍ＝＝ ｋ
ｐ ＞ｌｈ ｌ ＝ － ｃ ｉｄ ＮＵＬＬ；
ｉ（ ： １ ｆ ｍ ＝）
ｐ ＞ｒ ｈ ｌ ＝ － ｃ ｉ ＮＵＬ ； ｄ Ｌ
ｅｓ ｌｅ
ｅｓ ｌｅ
ｐ＞ｃ ｉ ＝ ｏｔ ｔｔ ｅｐ ｓｉ， －ｌ ｌ ｐ ｓｎｏｒ （ｏ ｔｎ ｈｄ ｉ ｅ ，
ｉ＋ ｋ Ｉｋｍ－ ） ， ｍ— —，， Ｉ； ｉ ｉ（ ｆ ｍ＝＝ ） ｈ
在 前序 序 列 中 的 第 一个 结 点 即为 二义 树 的
根 结点 ， 位置 为 ｉ。 中序序 ｐ 中 找到根 结 点 其 在 － ０ 位置 （ ， ｍ） 以确定左 右 子树上 的结点 （ 左 边 为 ｍ 左子 树 结点 ，右边 为 右子树 结 点 ） 。然 后再 到前
后 右子 树 ，最 后根 结 点 。 由前 序 遍 历 １ 遍 历序 列 或 者 由中序 遍 中序
前序遍历中序遍历复原方法
前序遍历中序遍历复原方法树是一种非线性的数据结构，它的一个重要性质就是可以通过不同的遍历顺序来表达树的结构。
在二叉树中，常用的三种遍历方式有前序遍历、中序遍历和后序遍历。
这三种遍历方式可以帮助我们了解树的结构，从而实现一些操作，比如复原树的结构。
在本文中，我们将讨论如何通过前序遍历和中序遍历的结果来复原一棵树的结构。
前序遍历、中序遍历和后序遍历是树的三种深度优先遍历方式。
它们的定义如下：-前序遍历：先访问根节点，再依次遍历左子树和右子树。
-中序遍历：先遍历左子树，再访问根节点，最后遍历右子树。
-后序遍历：先遍历左子树，再遍历右子树，最后访问根节点。
在这三种遍历方式中，前序遍历和中序遍历是最常用的。
在实际应用中，有时我们只能得到树的前序遍历和中序遍历结果，但想要还原树的结构。
那么，该如何通过前序遍历和中序遍历的结果来复原一棵树的结构呢？为了解决这个问题，我们首先需要知道前序遍历和中序遍历的性质。
在前序遍历中，第一个元素一定是根节点，在中序遍历中，根节点左边的元素都位于左子树中，根节点右边的元素都位于右子树中。
利用这些性质，我们可以进行如下步骤来复原树的结构：1.根据前序遍历的结果确定根节点。
2.在中序遍历的结果中找到根节点的位置，划分出左子树和右子树。
3.递归处理左子树和右子树，直到无法再继续递归。
下面，我们以一个具体的例子来说明如何通过前序遍历和中序遍历的结果来复原一棵树的结构。
假设我们有以下一棵树的前序遍历结果为[1,2,4,5,3,6,7]，中序遍历结果为[4,2,5,1,6,3,7]。
我们需要还原这棵树的结构。
首先，根据前序遍历的结果，我们可以知道根节点是1、然后，在中序遍历的结果中找到根节点1的位置，左子树为[4,2,5]，右子树为[6,3,7]。
接下来，我们递归处理左子树和右子树。
对于左子树，前序遍历结果为[2,4,5]，中序遍历结果为[4,2,5]。
根据前序遍历的结果，我们可以知道左子树的根节点是2、在中序遍历的结果中找到根节点2的位置，左子树为空，右子树为[4,5]。
数据结构课程设计二叉树遍历C++语言
淮阴工学院实践报告数据结构课程设计设计题目：二叉树遍历系别：计算机工程学院专业：软件工程班级：软件1111学生姓名: 周淼学号: 1111315217起止日期: 2012年12月24日~2012年12月30日指导教师：寇海洲摘要：现代社会生活中，计算机扮演着重要角色，而随着计算机运行速度的不断加快，对数据的处理能力也日益增强，因此，程序所涉及的数据成爆发式增长。
随之而来的问题就是如何科学有效的对数据进行操作，使得计算机的时间和空间利用率最高。
针对这样的问题，我选择了二叉树对数据的各种操作作为我的课程设计主题，希望通过课程设计来提高对数据的处理能力，促进对数据结构课程的理解，在日后面向对象的程序设计中科学的规划数据结构。
在本次课程设计中，二叉树的建立使用了递归算法，遍历则同时使用了递归与非递归的算法，同时，在遍历算法的实现中使用了栈结构与队列结构，这大大方便了二叉树的遍历。
在前序、中序、后续遍历算法中，分别实现了递归与非递归算法，从实际应用中体验了递归这一算法的优越性。
关键词：二叉树建立，递归与非递归，遍历，栈，队列编号：47淮阴工学院软件工程专业数据结构课程设计答辩记录课题名称：二叉树的算法班级软件1111 学号1111315217 姓名周淼记录人：寇海洲2012 年12 月28日目录1需求分析 (6)1.1二叉树与树结构 (6)1.2面向对象的程序设计 (6)1.3二叉树遍历的应用 (6)1.4软件运行环境：Visual C++ 6.0版本 (6)2概要设计 (7)2.1 总体功能结构 (7)2.2数据结构部分设计 (7)2.2.1结点结构 (7)2.2.2 二叉树结构 (8)3详细设计 (13)3.1建立二叉树 (13)3.1.1功能描述 (13)3.1.2算法原理 (13)3.1.3 具体程序 (13)3.2 前序遍历 (14)3.2.1 功能原理 (14)3.2.2 算法原理 (14)3.2.3 具体程序 (14)3.3 中序遍历 (15)3.3.1 功能原理 (15)3.3.2 算法原理 (15)3.3.3 具体程序 (15)3.4 后序遍历 (16)3.4.1功能原理 (16)3.4.2 算法原理 (16)3.4.3 具体程序 (17)3.5层次序非递归遍历 (18)3.5.1 功能原理 (18)3.5.2 算法原理 (18)3.5.3 具体程序 (18)3.6 栈结构 (19)3.6.1 功能原理 (19)3.6.2算法原理 (19)3.6.3 具体程序 (19)3.7 队列结构 (20)3.7.1 功能原理 (20)3.7.2 算法原理 (20)3.7.3 具体程序 (20)4调试与操作说明 (21)致谢 (24)参考文献 (25)附录： (26)1需求分析1.1二叉树与树结构树结构的是建立在数据逻辑结构基础上的数据结构类型，二叉树则是树结构中最常见和使用最多的类型。
C语言 二叉树的建立,撤销与遍历
C语言二叉树的建立，撤销与遍历二叉树是一种特殊的树，每个节点只能有最多二个孩子节点，或者没有孩子节点。
建立，与撤销或遍历二叉树主要是靠递归的方法。
#include<stdio.h>#include<stdlib.h>typedef struct stud/*定义二叉树的结构，只有一个数据项，和两个孩子节点*/{char data;struct stud *left;struct stud *right;} bitree;void destroy(bitree **root)/*撤销二叉树，这里用的是递归和二级指针*/ {if(*root!=NULL&&(*root)->left!=NULL)/*当前结点与左子树不空，递归撤销左子树*/destroy(&(*root)->left);if(*root!=NULL&&(*root)->right!=NULL)/*当前结点与右子树不空，递归撤销右子树*/destroy(&(*root)->right);free(*root);/*左右子树都为空，撤销该节点，并递归撤销其上的所有节点*/ }void inititate(bitree **root)/*初始化二叉树的头结点，并分配空间*/ {*root=(bitree *)malloc(sizeof(bitree ));(*root)->left=NULL;(*root)->right=NULL;}bitree *insert_left(bitree *curr,char x)/*在左子树插入数据*/{bitree *s,*t;if(curr==NULL)return NULL;t=curr->left;/*保存当前左子树的数据*/s=(bitree *)malloc(sizeof(bitree));s->data=x;s->left=t;/*新结点指向原来的左子树*/s->right=NULL;curr->left=s;/*原来的节点指向新结点*/return curr->left;}bitree *insert_right(bitree *curr,char x)/*在这个节点的右子树插入数据*/{bitree *s,*t;if(curr==NULL)return NULL;t=curr->right;s=(bitree *)malloc(sizeof(bitree));s->data=x;s->left=NULL;s->right=t;curr->right=s;return curr->right;}bitree *delete_left(bitree *curr)/*删除当前结点的左子树*/{if(curr!=NULL&&curr->left!=NULL)destroy(&curr->left);/*删除左子树本身及其以后的所有节点*/curr->left=NULL;return curr;}bitree *delete_right(bitree *curr)/*删除右子树*/{if(curr!=NULL&&curr->right!=NULL)destroy(&curr->right);curr->right=NULL;return curr;}void preorder(bitree *root)/*递归先序遍历根节点*/ {if(root!=NULL){printf("%c ",root->data);preorder( root->left);preorder( root->right);}}void midorder(bitree *root)/*递归中序遍历根节点*/ {if(root!=NULL){midorder( root->left);printf("%c ",root->data);midorder(root->right);}}void postorder(bitree *root))/*递归后序遍历根节点*/ {if(root!=NULL){postorder(root->left);postorder( root->right);printf("%c ",root->data);}}bitree *search(bitree *root,char x))/*递归某一数值*/ {bitree *find=NULL;if(root!=NULL){if(root->data==x)find=root;else{find=search (root->left,x);)/*在左子树查找*/ if(find==NULL))/*左子树没有找到的话*/find=search (root->right,x);/*右子树找*/}}return find;}void main(){bitree *root,*s,*p,*find;int i,j,k;char c='E';inititate(&root);p=insert_left(root,'A');p=insert_left(p,'B');p=insert_left(p,'D');p=insert_right(p,'G');p=insert_right(root->left,'C');insert_left(p,'E');insert_right(p,'F');printf("前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);find=search(root->left,c);if(find)printf("这个元素%c在二叉树中\n",c);elseprintf("这个元素%c不在二叉树中\n",c);printf("撤销根节点的左子树为\n");delete_left(root->left);printf("\n前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);printf("\n撤销根节点的右子树为\n"); delete_right(root->left);printf("前序遍历为\n");preorder(root->left);printf("\n中序遍历为\n");midorder(root->left);printf("\n后序遍历为\n");postorder(root->left);destroy(&root);}。
二叉树的遍历代码
二叉树的遍历代码二叉树是一种非常常见的数据结构，它由根节点、左子树和右子树组成，可以用于实现各种算法和应用。
在使用二叉树时，我们常常需要进行遍历来获取树中的节点信息。
下面，我们将详细介绍二叉树的遍历方法及其代码实现。
二叉树的遍历方法分为三种：前序遍历、中序遍历和后序遍历。
它们的不同之处在于遍历节点的顺序不同。
我们分别来介绍一下这三种遍历方法。
1.前序遍历前序遍历的顺序是：先访问根节点，然后递归访问左子树和右子树。
实现前序遍历的代码如下：```pythondef preorder_traversal(node):if node:print(node.data)preorder_traversal(node.left)preorder_traversal(node.right)```在代码中，我们首先输出根节点的值，然后分别递归访问左子树和右子树，直到遍历完整个树。
2.中序遍历中序遍历的顺序是：先递归访问左子树，然后访问根节点，最后递归访问右子树。
实现中序遍历的代码如下：```pythondef inorder_traversal(node):if node:inorder_traversal(node.left)print(node.data)inorder_traversal(node.right)```在代码中，我们先递归访问左子树，然后输出根节点的值，最后递归访问右子树。
3.后序遍历后序遍历的顺序是：先递归访问左子树和右子树，然后访问根节点。
实现后序遍历的代码如下：```pythondef postorder_traversal(node):if node:postorder_traversal(node.left)postorder_traversal(node.right)print(node.data)```在代码中，我们先递归访问左子树和右子树，然后输出根节点的值。
通过前序遍历、中序遍历和后序遍历，我们可以获取二叉树中每个节点的值。
数据结构——用C语言描述(第3版)教学课件第6章 树与二叉树
6.2 二叉树 6.2.1 二叉树的定义与基本操作 6.2.2 二叉树的性质 6.2.3 二叉树的存储结构
6.2.1 二叉树的定义与基本操作 定义：我们把满足以下两个条件的树型结构叫做二 叉树（Binary Tree）： （1）每个结点的度都不大于2； （2）每个结点的孩子结点次序不能任意颠倒。
有序树：在树T中，如果各子树Ti之间是有先后次序的，则称为有序树。 森林：m（m≥0）棵互不相交的树的集合。将一棵非空树的根结点删去，树就变成一 个森林；反之，给森林增加一个统一的根结点，森林就变成一棵树。
同构：对两棵树，通过对结点适当地重命名，就可以使两棵树完全相等（结点对应相 等，对应结点的相关关系也像等），则称这两棵树同构。
二叉树的基本结构由根结点、左子树和右子树组成
如图示
LChild Data RChild
Data
LChild RChild
用L、D、R分别表示遍历左子树、访问根结点、遍 历右子树，那么对二叉树的遍历顺序就可以有：
(1) 访问根，遍历左子树，遍历右子树(记做DLR)。 (2) 访问根，遍历右子树，遍历左子树(记做DRL)。 (3) 遍历左子树，访问根，遍历右子树(记做LDR)。 (4) 遍历左子树，遍历右子树，访问根 (记做LRD)。 (5) 遍历右子树，访问根，遍历左子树 (记做RDL)。 (6) 遍历右子树，遍历左子树，访问根 (记做RLD)。
(8) NextSibling（Tree，x）： 树Tree存在，x是Tree中的某个结点。若x不 是其双亲的最后一个孩子结点，则返回x后面的下一个兄弟结点，否则 返回“空”。
基本操作:
(9) InsertChild（Tree，p，Child）： 树Tree存在，p指向Tree 中某个结点，非空树Child与Tree不相交。将Child插入Tree中， 做p所指向结点的子树。
c++实现树（二叉树）的建立和遍历算法（一）（前序，中序，后序）
c++实现树（⼆叉树）的建⽴和遍历算法（⼀）（前序，中序，后序）最近学习树的概念，有关⼆叉树的实现算法记录下来。
不过学习之前要了解的预备知识：树的概念；⼆叉树的存储结构；⼆叉树的遍历⽅法。
⼆叉树的存储结构主要了解⼆叉链表结构，也就是⼀个数据域，两个指针域，（分别为指向左右孩⼦的指针），从下⾯程序1，⼆叉树的存储结构可以看出。
⼆叉树的遍历⽅法：主要有前序遍历，中序遍历，后序遍历，层序遍历。
（层序遍历下⼀篇再讲，本篇主要讲的递归法）下篇主要是，之后会有c++模板实现和。
如这样⼀个⼆叉树：它的前序遍历顺序为：ABDGHCEIF（规则是先是根结点，再前序遍历左⼦树，再前序遍历右⼦树）它的中序遍历顺序为：GDHBAEICF（规则是先中序遍历左⼦树，再是根结点，再是中序遍历右⼦树）它的后序遍历顺序为：GHDBIEFCA（规则是先后序遍历左⼦树，再是后序遍历右⼦树，再是根结点）如果不懂的话，可以参看有关数据结构的书籍。
1，⼆叉树的存储结构（⼆叉链表）//⼆叉树的⼆叉链表结构，也就是⼆叉树的存储结构，1个数据域，2个指针域（分别指向左右孩⼦）typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;2，⾸先要建⽴⼀个⼆叉树，建⽴⼆叉树必须要了解⼆叉树的遍历⽅法。
//⼆叉树的建⽴，按前序遍历的⽅式建⽴⼆叉树，当然也可以以中序或后序的⽅式建⽴⼆叉树void CreateBiTree(BiTree *T){ElemType ch;cin >> ch;if (ch == '#')*T = NULL; //保证是叶结点else{*T = (BiTree)malloc(sizeof(BiTNode));//if (!*T)//exit(OVERFLOW); //内存分配失败则退出。
C语言实现二叉树的中序遍历（递归）
C语 言 实 现 二 叉 树 的 中 序 遍 历 （ 递 归 ）
二叉树的前序遍历、中序遍历、后续遍历 （包括递归、非递归，共六种） 1、中序遍历（递归）： #include #include struct BiTNode//定义结构体 { char data; struct BiTNode *lchild,*rchild; }; void later(struct BiTNode *&p) //前序创建树 { char ch; scanf("%c",&ch); if(ch==' ') p=NULL; else { p=(struct BiTNode *)malloc(sizeof(struct BiTNode)); p->data=ch; later(p->lchild); later(p->rchild); } } void print(struct BiTNode *p) //中序遍历（输出二叉树） { if(p!=NULL) { print(p->lchild); printf("%c",p->data); print(p->rchild); } else printf(" ");
中序遍历二叉树的递归算法c语言代码
中序遍历二叉树的递归算法c语言代码二叉树的中序遍历递归算法是左子树-> 根节点-> 右子树。
以下是C语言代码实现：```c#include <stdio.h>#include <stdlib.h>// 定义二叉树节点结构体struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};// 定义二叉树中序遍历函数void inorderTraversal(struct TreeNode *root) {if (root == NULL) { // 如果根节点为空，直接返回return;}inorderTraversal(root->left); // 先遍历左子树printf("%d ", root->val); // 输出根节点值inorderTraversal(root->right); // 最后遍历右子树}int main() {// 创建一棵二叉树struct TreeNode *root = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node1 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node2 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node3 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node4 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node5 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node6 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node7 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node8 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node9 = (struct TreeNode*)malloc(sizeof(struct TreeNode));node1->val = 1;node1->left = node2;node1->right = node3;node2->val = 2;node2->left = NULL;node2->right = NULL;node3->val = 3;node3->left = node4;node3->right = node5;node4->val = 4;node4->left = NULL;node4->right = NULL;node5->val = 5;node5->left = NULL;node5->right = NULL;root->val = 0; // 设置根节点值为0，这样在遍历时会跳过根节点输出0，避免输出多个根节点值。
浅析一种二叉树非递归遍历算法的C语言实现论文.doc
浅析一种二叉树非递归遍历算法的C语言实现论文一种二叉树非递归遍历算法的C语言实现论文导读：本论文是一篇关于一种二叉树非递归遍历算法的C语言实现的优秀论文范文,对正在写有关于递归论文的写有一定的参考和指导作用,摘要：针对二叉树的链式存储结构，分析了二叉树的各种遍历算法，探讨了递归算法的递推消除理由，提出了一种改善的非递归遍历算法并用C语言予以实现。
关键词：二叉树；遍历算法；非递归；C语言实现1009-3044（2014）01-0223-031 概述树形结构是一种非常常见的数据结构，而二叉树又是其中最重要的一种树形结构。
二叉树的遍历是指按照一定的规则和次序将二叉树中的每一个结点都访问一次，既不能重复，也不能漏掉。
一般而言，对二叉树的遍历有前序遍历、中序遍历、后序遍历和按层遍历等几种方式。
在具体的算法设计上，以上遍历方式一般采取递归算法来实现，该文将探讨采用非递归算法来实现二叉树的遍历。
2 二叉树的数据结构描述二叉树作为一种非线性结构，每个结点最多有一个双亲结点和两个子结点。
二叉树可以采用顺序存储结构和链式存储结构。
对于完全二叉树而言，采用顺序存储是非常方便并且节省空间的，但是对于大部分的非完全二叉树而言，采用顺序存储将导致空间浪费严重且结构混乱、效率低下。
因此，更多的时候，大家都更愿意用链式存储结构来表示二叉树，这样结构更加清晰，尤其是对于一种二叉树非递归遍历算法的C语言实现由写论文的好帮手.zbjy.提供,.左右子树的描述和双亲节点的描述更加方便。
该文中拟采用链式结构来表示二叉树。
用链式存储结构来表示二叉树，一个结点至少由3个域组成，即数据域、左子结点域和右子结点域（如图1所示）。
3 二叉树的遍历及递归算法实现3.1 二叉树的遍历二叉树的遍历就是一个不漏的访问树中的每个结点，同时也不能重复。
所谓“访问”，就是指对结点的数据域进行某种操作，比如说读取、删除、更新、求该节点深度等等。
对于二叉树中的任意一个部分，都可以把它看作三部分，根节点、左子树、右子树，我们用D表示访问跟结点，用L表示遍历左子树，用R表示遍历右子树，则共有以下6种遍历方式[1]。
用C语言编写二叉树的建立与遍历
用C语言编写二叉树的建立与遍历1．对题目要有需求分析在需求分析中，将题目中要求的功能进行叙述分析，并且设计解决此问题的数据存储结构，设计或叙述解决此问题的算法。
给出实现功能的一组或多组测试数据，程序调试后，将按照此测试数据进行测试的结果列出来。
如果程序不能正常运行，写出实现此算法中遇到的问题和改进方法；2．对题目要有相应的源程序源程序要按照写程序的规则来编写。
要结构清晰，重点函数的重点变量，重点功能部分要加上清晰的程序注释。
(注释量占总代码的四分之一)程序能够运行，要有基本的容错功能。
尽量避免出现操作错误时出现死循环；3．最后提供的主程序可以象一个应用系统一样有主窗口，通过主菜单和分级菜单调用课程设计中要求完成的各个功能模块，调用后可以返回到主菜单，继续选择其他功能进行其他功能的选择。
二叉树的建立与遍历[问题描述]建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。
[基本要求]从键盘接受输入，以二叉链表作为存储结构，建立二叉树，并对其进行遍历（先序、中序、后序），将遍历结果打印输出。
以下是我的数据结构实验的作业：肯定好用，里面还包括了统计树的深度和叶子数！记住每次做完一个遍历还要重新输入你的树哦！#include "stdio.h"#include "string.h"#define NULL 0typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild); }return T;}void Preorder(BiTree T){if(T){printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void zhongxu(BiTree T){if(T){zhongxu(T->lchild);printf("%c",T->data); zhongxu(T->rchild);}}void houxu(BiTree T){if(T){houxu(T->lchild);houxu(T->rchild);printf("%c",T->data);}}int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}main(){BiTree T;int sum,dep;T=Create(T);Preorder(T);printf("\n");zhongxu(T);printf("\n");houxu(T);printf("\n");sum=Sumleaf(T);printf("%d",sum);dep=Depth(T);printf("\n%d",dep);}在Turbo C的环境下，先按Ctrl+F9运行程序，此时就是建立二叉树的过程，例如输入序列ABC##DE#G##F###（其中的“#”表示空，并且输入过程中不要加回车，因为回车也有对应的ASCII码，是要算字符的，但是输入完之后可以按回车退出），然后再按ALT+F5显示用户界面，这时候就能够看到结果了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//
Create(T->Right,i+1,end,len-1);
//
}
//
// }
// }
// else{
// T->Left = NULL;
// T->Right = NULL;
// }
}
void PrintTreeNode(BiTree T,BiTree *node)
{
node = (BiTree*)malloc(sizeof (BiTreeNode ) * 110);
} if(len>=0 && end>begin){
for(i=begin; i<=end; i++){
if(in[i] == post[num]){ break;
} } } T = (BiTreeNode*)malloc( sizeof( BiTreeNode ) );
T->Element = post[num];
char Element; struct BiTreeNode *Left; struct BiTreeNode *Right; }*BiTree; BiTree node[110];
char in[110],post[110]; int cnt=0,leห้องสมุดไป่ตู้;
void Create(BiTree &T,int begin,int end,int num) {
}
front++;
}
front=0;
while(front<rear){
printf("%c",node[front++]->Element);
}
printf("\n");
}
//{
// if(T != NULL){
// if(T->Left != NULL){
//
printf("%c",T->Left->Element);
// }
// if(T->Right != NULL){
//
printf("%c",T->Right->Element);
// }
// PrintTreeNode(T->Left);
// PrintTreeNode(T->Right);
// }
//}
int main() {
BiTree T; gets(in); gets(post); len = strlen(post); len--; Create(T,0,len,len); PrintTreeNode(T,node);
int front=0,rear=0;
node[rear++] = T;
while(front<rear){
if(node[front]->Left!=NULL){
node[rear++] = node[front]->Left;
}
if(node[front]->Right!=NULL){
node[rear++] = node[front]->Right;
T->Left = NULL;
T->Right = NULL;
cnt++;
if(i+1<=end)
Create(T->Right,i+1,end,len-cnt);
if(begin<=i-1)
Create(T->Left,begin,i-1,len-cnt);
// if(len>=0 && end>begin){
// PrintTreeNode(T->Right);
// }
//}
//{
// if(T != NULL){
// if(T->Left != NULL){
//
printf("%c",T->Left->Element);
// }
// if(T->Right != NULL){
//
printf("%c",T->Right->Element);
/**************************************************** 中序+后序，还原二叉树************************************/ #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct BiTreeNode {
//
printf("%c",T->Right->Element);
// }
// PrintTreeNode(T->Left);
// PrintTreeNode(T->Right);
// }
//}
//
T->Element = post[len];
//
T->Left = NULL;
//
T->Right = NULL;
//
//
Create(T->Left,begin,i-1,len-1);
//
}
//
for(int j=i+1; j<len; j++){
//
if(in[j] == post[len-1])
// for(i=begin; i<=end; i++){
//
if(in[i] == post[len]){
//
flag = 0;
//
break;
//
}
// }
// if(!flag ){
//
T = (BiTreeNode*)malloc( sizeof( struct BiTreeNode ) );
int i; if(end == begin){
T = (BiTreeNode*)malloc( sizeof( struct BiTreeNode ) ); T->Element = in[begin]; T->Left = NULL; T->Right = NULL;
cnt++; return;
} //{ // if(T != NULL){
// if(T->Left != NULL){
//
printf("%c",T->Left->Element);
// }
// if(T->Right != NULL){
//
printf("%c",T->Right->Element);
// }
// PrintTreeNode(T->Left);
// }
// PrintTreeNode(T->Left);
// PrintTreeNode(T->Right);
// }
//}
//{
// if(T != NULL){
// if(T->Left != NULL){
//
printf("%c",T->Left->Element);
// }
// if(T->Right != NULL){