二叉树遍历所有代码
汇编二叉树的遍历
一、软件背景介绍树的遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。
访问结点所做的操作依赖于具体的应用问题。
遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算的基础。
从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。
因此，在任一给定结点上，可以按某种次序执行三个操作：⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。
所以二叉树的遍历也包括三种：先序遍历，中序遍历，和后序遍历。
图1：程序显示结果二、核心算法思想二叉树的存储：在内存中为数组binary分配一个大小为63（0，0，0）的存储空间，所有数组元素初始化为0，用来存放二叉树。
每三个连续的数组地址存放一个节点：第一个地址存放节点的值；第二个地址存放有无左孩子的信息，如果有则将其置为1，否则为0；第三个地址存放有无右孩子的信息，如果有则将其置为1，否则为0。
将binary的首址偏移赋给si，cx初始化为0用来计数，用回车代表输入的为空，即没有输入。
按先根存储的方式来存二叉树，首先输入一个字符，若为回车则退出程序，否则cx+3且调用函数root。
然后该结点若有左孩子，调用leftchild函数，置该结点标志即第二个地址中的0为1，该结点进栈，再存储左孩子结点，递归调用左右，若没有左孩子，看有没有右孩子，若有，则调用rightchild置该结点标志位即上第三个地址中的0为1，然后该结点进栈，再存储右孩子结点，递归调用左右，整个用cx计数，数组binary中每多一个节点，cx加3。
此存储方式正好符合先序遍历思想。
遍历二叉树的执行踪迹：三种递归遍历算法的搜索路线相同，具体线路为：从根结点出发，逆时针沿着二叉树外缘移动，对每个结点均途径三次，最后回到根结点。
二叉树的遍历有常用的三种方法，分别是：先根次序、中根次序、后根次序。
为了验证这几种遍历算法的区别，本次的实验将会实现所有的算法。
二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）
⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。
对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。
由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。
⽐⽅堆了。
所以。
对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。
四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。
求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。
然后在訪问左⼦树和右⼦树。
所以。
对于随意结点node。
第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。
若为空。
则须要訪问右⼦树。
注意。
在訪问过左孩⼦之后。
实现二叉树的各种遍历算法实验报告
if(a[i]>kmax) kmax = a[i]; return kmax; } /** 求二叉树的节点个数 **/ int Nodes(BTNode *b) { if(b==NULL)
2.2：（ 1 ）实现二叉树的先序遍历 （ 2）实现二叉树的中序遍历 （ 3）实现二叉树的后序遍历
三 实验内容 :
3.1 树的抽象数据类型 : ADT Tree{
.专业 .整理 .
下载可编辑
数据对象 D： D 是具有相同特性的数据元素的集合 。 数据关系 R： 若 D 为空集 ， 则称为空树 ；
若 D 仅含有一个数据元素 ，则 R 为空集 ， 否则 R={H} ， H 是如 下二元关系 ：
if(b!=NULL) {
printf("%c",b->data); if(b->lchild!=NULL || b->rchild!=NULL) {
printf(" （"); DispBTNode(b->lchild); if(b->rchild != NULL)printf(" ， "); DispBTNode(b->rchild); printf(" ）"); } } } /** 深度 **/ int BTNodeDepth(BTNode *b)
下载可编辑
实现二叉树的各种遍历算法实验报告
一 实验题目 : 实现二叉树的各种遍历算法 二 实验要求 :
2.1:（1 ） 输出二叉树 b （ 2）输出 H 节点的左右孩子节点值 （ 3）输出二叉树 b 的深度 （ 4）输出二叉树 b 的宽度 （ 5）输出二叉树 b 的节点个数 （ 6）输出二叉树 b 的叶子节点个数 （ 7）释放二叉树 b
二叉树遍历大全
二叉树的前序遍历、中序遍历、后续遍历（包括递归、非递归，共六种）1、前序遍历（递归）：算法实现一：#include <stdio.h>#include <stdlib.h>typedef struct BiTNode//定义结构体{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;void CreateBiTree(BiTree &T) //前序创建树{char ch;scanf("%c",&ch);if(ch==' ') T=NULL;else{T=(struct BiTNode *)malloc(sizeof(struct BiTNode));T->data=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int print(BiTree T)//前序遍历（输出二叉树）{if(T==NULL)return 0;else if(T->lchild==NULL && T->rchild==NULL)return 1;else return print(T->lchild)+print(T->rchild);}void main()//主函数{BiTree T;CreateBiTree(T);printf("%d\n",print(T));}算法实现二：#include<stdio.h>#include<stdlib.h>struct BiTNode//定义结构体{char data;struct BiTNode *lchild,*rchild;};int num=0;void CreatBiTree(struct BiTNode *&p) //前序创建树{char ch;scanf("%c",&ch);if(ch==' ') p=NULL;else{p=(struct BiTNode *)malloc(sizeof(struct BiTNode));p->data=ch;CreatBiTree(p->lchild);CreatBiTree(p->rchild);}}void print(struct BiTNode *p) //前序遍历（输出二叉树）{if(p!=NULL){if(p->lchild==NULL&&p->rchild==NULL)else{print(p->lchild);print(p->rchild);}}}void main()//主函数{struct BiTNode *p;CreatBiTree(p);print(p);printf("%d\n",num);}#include<stdio.h>#include<stdlib.h>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);}elseprintf(" ");}void main()//主函数{struct BiTNode *p;later(p);print(p);}#include<stdio.h>#include<stdlib.h>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);print(p->rchild);printf("%c",p->data);}elseprintf(" ");}void main()//主函数{/*检测：printf("到了吗");*/struct BiTNode *p;later(p);print(p);}#include<stdio.h>#include<stdlib.h>struct BiTNode *stack[100];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) //前序遍历（输出二叉树）{int i=-1;while(1){while(p!=NULL){stack[++i]=p->rchild;/*printf("ok？\n");*/printf("%c",p->data);p=p->lchild;}if(i!=-1){p=stack[i];i--;}elsereturn;}}void main()//主函数{struct BiTNode *p,*t;later(p);print(p);}5、中序遍历（非递归）#include<stdio.h>#include<stdlib.h>struct BiTNode *stack[100];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) //中序遍历（输出二叉树）{int i=-1;while(1){while(p!=NULL){i++;stack[i]=p;p=p->lchild;}if(i!=-1){p=stack[i];i--;printf("%c",p->data);p=p->rchild;}}}void main()//主函数{struct BiTNode *p;later(p);print(p);}6、后续遍历（非递归）：#include<stdio.h>#include<stdlib.h>struct BiTNode *stack[100];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) //后序遍历（输出二叉树）{int i=-1;while(1){while(p!=NULL){stack[++i]=p;/*printf.0("ok？\n");*/p=p->lchild;}if(i!=-1){while(p==stack[i]->rchild||(p==stack[i]->lchild&&stack[i]->rchild==NULL)) {p=stack[i--];printf("%c",p->data);if(i==-1)return;}p=stack[i]->rchild;}elsereturn;}}int main()//主函数{struct BiTNode *p,*t;later(p);print(p);printf("\n");system("pause");return 0;}供测试使用的数据。
平衡二叉树实现代码
平衡二叉树实现代码平衡二叉树（Balanced Binary Tree），也叫 AVL 树，是一种特殊的二叉树，它的每个节点的左子树和右子树的高度差不超过1、当插入或删除一个节点后，如果导致树的不平衡，就通过旋转操作来恢复平衡。
下面是平衡二叉树的实现代码：```python#定义平衡二叉树的节点类class AVLNode:def __init__(self, key):self.key = keyself.left = Noneself.right = Noneself.height = 1#定义平衡二叉树类class AVLTree:def __init__(self):self.root = None#获取节点的高度def get_height(self, node):if node is None:return 0return node.height#计算平衡因子def get_balance(self, node):if node is None:return 0return self.get_height(node.left) -self.get_height(node.right)#左旋操作def left_rotate(self, z):y = z.rightT2 = y.lefty.left = zz.right = T2z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))return y#右旋操作def right_rotate(self, z):y = z.leftT3 = y.righty.right = zz.left = T3z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))return y#插入节点def insert(self, key):def insert_node(node, key):if node is None:return AVLNode(key)elif key < node.key:node.left = insert_node(node.left, key)else:node.right = insert_node(node.right, key)node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))balance = self.get_balance(node)#如果节点不平衡，进行旋转操作来恢复平衡if balance > 1:if key < node.left.key:return self.right_rotate(node)else:node.left = self.left_rotate(node.left)return self.right_rotate(node)if balance < -1:if key > node.right.key:return self.left_rotate(node)else:node.right = self.right_rotate(node.right)return self.left_rotate(node)return nodeself.root = insert_node(self.root, key)#删除节点def delete(self, key):def delete_node(node, key):if node is None:return nodeelif key < node.key:node.left = delete_node(node.left, key) elif key > node.key:node.right = delete_node(node.right, key) else:if node.left is None:temp = node.rightnode = Nonereturn tempelif node.right is None:temp = node.leftnode = Nonereturn temptemp = self.get_min_value_node(node.right)node.key = temp.keynode.right = delete_node(node.right, temp.key)if node is None:return nodenode.height = 1 + max(self.get_height(node.left), self.get_height(node.right))balance = self.get_balance(node)#如果节点不平衡，进行旋转操作来恢复平衡if balance > 1:if self.get_balance(node.left) >= 0:return self.right_rotate(node)else:node.left = self.left_rotate(node.left)return self.right_rotate(node)if balance < -1:if self.get_balance(node.right) <= 0:return self.left_rotate(node)else:node.right = self.right_rotate(node.right)return self.left_rotate(node)return nodeself.root = delete_node(self.root, key) #获取以一些节点为根的子树中的最小值节点def get_min_value_node(self, node):if node is None or node.left is None: return nodereturn self.get_min_value_node(node.left) #中序遍历树def inorder_traversal(self):def inorder(node):if node is None:returninorder(node.left)print(node.key, end=" ")inorder(node.right)inorder(self.root)#测试代码if __name__ == '__main__':tree = AVLTreenodes = [50, 30, 70, 20, 40, 60, 80, 25, 10, 55]for node in nodes:tree.insert(node)print("平衡二叉树中序遍历结果：")tree.inorder_traversalprint("\n删除节点 40 后的平衡二叉树中序遍历结果：")tree.delete(40)tree.inorder_traversal```以上就是平衡二叉树的实现代码，代码中包含了平衡二叉树节点类的定义，以及插入节点、删除节点、左旋和右旋操作等方法的实现。
二叉树遍历（前中后序遍历，三种方式）
⼆叉树遍历（前中后序遍历，三种⽅式）⽬录刷题中碰到⼆叉树的遍历，就查找了⼆叉树遍历的⼏种思路，在此做个总结。
对应的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)的空间复杂度。
数据结构二叉树的基本操作代码
数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。
二叉树遍历所有代码
#include <stdio.h>#include <iostream>#include <queue>#include <stack>#include <malloc.h>#define SIZE 100using namespace std;typedef struct BiTNode //定义二叉树节点结构{char data; //数据域struct BiTNode *lchild,*rchild; //左右孩子指针域}BiTNode,*BiTree;int visit(BiTree t);void CreateBiTree(BiTree &T); //生成一个二叉树void PreOrder(BiTree); //递归先序遍历二叉树void InOrder(BiTree); //递归中序遍历二叉树void PostOrder(BiTree); //递归后序遍历二叉树void InOrderTraverse(BiTree T); //非递归中序遍历二叉树void PreOrder_Nonrecursive(BiTree T);//非递归先序遍历二叉树void LeverTraverse(BiTree T);//非递归层序遍历二叉树//主函数void main(){BiTree T;char j;int flag=1;//---------------------程序解说-----------------------printf("本程序实现二叉树的操作。
\n");printf("叶子结点以空格表示。
\n");printf("可以进行建立二叉树，递归先序、中序、后序遍历，非递归先序、中序遍历及非递归层序遍历等操作。
\n");//----------------------------------------------------printf("\n");printf("请建立二叉树。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>#include <iostream>#include <queue>#include <stack>#include <malloc.h>#define SIZE 100using namespace std;typedef struct BiTNode //定义二叉树节点结构{char data; //数据域struct BiTNode *lchild,*rchild; //左右孩子指针域}BiTNode,*BiTree;int visit(BiTree t);void CreateBiTree(BiTree &T); //生成一个二叉树void PreOrder(BiTree); //递归先序遍历二叉树void InOrder(BiTree); //递归中序遍历二叉树void PostOrder(BiTree); //递归后序遍历二叉树void InOrderTraverse(BiTree T); //非递归中序遍历二叉树void PreOrder_Nonrecursive(BiTree T);//非递归先序遍历二叉树void LeverTraverse(BiTree T);//非递归层序遍历二叉树//主函数void main(){BiTree T;char j;int flag=1;//---------------------程序解说-----------------------printf("本程序实现二叉树的操作。
\n");printf("叶子结点以空格表示。
\n");printf("可以进行建立二叉树，递归先序、中序、后序遍历，非递归先序、中序遍历及非递归层序遍历等操作。
\n");//----------------------------------------------------printf("\n");printf("请建立二叉树。
\n");printf("建树将以三个空格后回车结束。
\n");printf("例如:1 2 3 4 5 6 (回车)\n"); CreateBiTree(T); //初始化队列getchar();while(flag){printf("请选择: \n");printf("1.递归先序遍历\n");printf("2.递归中序遍历\n");printf("3.递归后序遍历\n");printf("4.非递归中序遍历\n");printf("5.非递归先序遍历\n");printf("6.非递归层序遍历\n");printf("0.退出程序\n");scanf(" %c",&j);switch(j){case '1':if(T){printf("递归先序遍历二叉树:"); PreOrder(T);printf("\n");}else printf("二叉树为空!\n");break;case '2':if(T){printf("递归中序遍历二叉树:"); InOrder(T);printf("\n");}else printf("二叉树为空!\n");break;case '3':if(T){printf("递归后序遍历二叉树:"); PostOrder(T);printf("\n");}else printf("二叉树为空!\n");break;case '4':if(T){printf("非递归中序遍历二叉树:"); InOrderTraverse(T);printf("\n");}else printf("二叉树为空!\n");break;{printf("非递归先序遍历二叉树:");PreOrder_Nonrecursive(T);printf("\n");}else printf("二叉树为空!\n");break;case '6':if(T){printf("非递归层序遍历二叉树:");LeverTraverse(T);printf("\n");}else printf("二叉树为空!\n");break;default:flag=0;printf("程序运行结束，按任意键退出!\n"); }}}//建立二叉树void CreateBiTree(BiTree &T){char ch;scanf("%c",&ch); //读入一个字符if(ch==' ') T=NULL;else{T=(BiTNode *)malloc(sizeof(BiTNode)); //生成一个新结点 T->data=ch;CreateBiTree(T->lchild); //生成左子树CreateBiTree(T->rchild); //生成右子树}}//先序遍历的递归void PreOrder(BiTree T){if(T){printf("%c ",T->data); //访问结点PreOrder(T->lchild); //遍历左子树PreOrder(T->rchild); //遍历右子树 }}//中序遍历的递归void InOrder(BiTree T){if(T){InOrder(T->lchild); //遍历左子树 printf("%c ",T->data); //访问结点 InOrder(T->rchild); //遍历右子树 }}//后序遍历的递归void PostOrder(BiTree T){if(T){PostOrder(T->lchild); //遍历左子树 PostOrder(T->rchild); //访问结点 printf("%c ",T->data); //遍历右子树 }}//非递归中序遍历void InOrderTraverse(BiTree T) {stack<BiTree> S;BiTree p;S.push(T);//跟指针进栈while(!S.empty()){p=new BiTNode;while((p=S.top())&&p)S.push(p->lchild);//向左走到尽头 S.pop(); //空指针退栈if(!S.empty()){p=S.top();S.pop();cout<<p->data<<" ";S.push(p->rchild);}}}//先序遍历的非递归void PreOrder_Nonrecursive(BiTree T) {stack<BiTree> S;BiTree p;S.push(T);//根指针进栈while(!S.empty())//栈空时结束{while((p=S.top())&&p){cout<<p->data<<" ";S.push(p->lchild);}//向左走到尽头S.pop();//弹出堆栈if(!S.empty()){p=S.top();S.pop();S.push(p->rchild);//向右走一步}}}void LeverTraverse(BiTree T){//非递归层次遍历queue <BiTree> Q;BiTree p;p = T;if(visit(p)==1)Q.push(p);while(!Q.empty()){p = Q.front();Q.pop();if(visit(p->lchild) == 1)Q.push(p->lchild);if(visit(p->rchild) == 1)Q.push(p->rchild); }}int visit(BiTree T) {if(T){printf("%c ",T->data); return 1;}elsereturn 0;}。