先序建立二叉树

合集下载

二叉树的建立与基本操作

二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（node）组成，每个节点最多有两个子节点。

二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。

本文将详细介绍二叉树的建立和基本操作，并给出相应的代码示例。

一、建立二叉树建立二叉树有多种方法，包括使用数组、链表和前序、中序、后序遍历等。

下面以使用链表的方式来建立二叉树为例。

1.定义二叉树节点类首先，定义一个二叉树节点的类，包含节点值、左子节点和右子节点三个属性。

```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树，先构造根节点，然后递归地构造左子树和右子树。

```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空，则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码：```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。

1.前序遍历前序遍历是指先访问根节点，然后访问左子节点，最后访问右子节点。

```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。

二叉树的建立与先序中序后序遍历求叶子节点个数求分支节点个数求二叉树的高度

/*一下总结一些二叉树的常见操作：包括建立二叉树先/中/后序遍历二叉树求二叉树的叶子节点个数求二叉树的单分支节点个数计算二叉树双分支节点个数计算二叉树的高度计算二叉树的所有叶子节点数*/#include<stdio.h> //c语言的头文件#include<stdlib.h>//c语言的头文件stdlib.h千万别写错了#define Maxsize 100/*创建二叉树的节点*/typedef struct BTNode //结构体struct 是关键字不能省略结构体名字可以省略（为无名结构体）//成员类型可以是基本型或者构造形，最后的为结构体变量。

{char data;struct BTNode *lchild,*rchild;}*Bitree;/*使用先序建立二叉树*/Bitree Createtree() //树的建立{char ch;Bitree T;ch=getchar(); //输入一个二叉树数据if(ch==' ') //' '中间有一个空格的。

T=NULL;else{ T=(Bitree)malloc(sizeof(Bitree)); //生成二叉树(分配类型*)malloc(分配元素个数*sizeof(分配类型))T->data=ch;T->lchild=Createtree(); //递归创建左子树T->rchild=Createtree(); //地柜创建右子树}return T;//返回根节点}/*下面先序遍历二叉树*//*void preorder(Bitree T) //先序遍历{if(T){printf("%c-",T->data);preorder(T->lchild);preorder(T->rchild);}} *//*下面先序遍历二叉树非递归算法设计*/void preorder(Bitree T) //先序遍历非递归算法设计{Bitree st[Maxsize];//定义循环队列存放节点的指针Bitree p;int top=-1; //栈置空if(T){top++;st[top]=T; //根节点进栈while(top>-1) //栈不空时循环{p=st[top]; //栈顶指针出栈top--;printf("%c-",p->data );if(p->rchild !=NULL) //右孩子存在进栈{top++;st[top]=p->rchild ;}if(p->lchild !=NULL) //左孩子存在进栈{top++;st[top]=p->lchild ;}}printf("\n");}}/*下面中序遍历二叉树*//*void inorder(Bitree T) //中序遍历{if(T){inorder(T->lchild);printf("%c-",T->data);inorder(T->rchild);}}*//*下面中序遍历二叉树非递归算法设计*/void inorder(Bitree T) //中序遍历{Bitree st[Maxsize]; //定义循环队列，存放节点的指针Bitree p;int top=-1;if(T){p=T;while (top>-1||p!=NULL) //栈不空或者*不空是循环{while(p!=NULL) //扫描*p的所有左孩子并进栈{top++;st[top]=p;p=p->lchild ;}if(top>-1){p=st[top]; //出栈*p节点，它没有右孩子或右孩子已被访问。

天大《数据结构》学习笔记四

主题：《数据结构》学习笔记内容：《数据结构》学习笔记四——树一、树形结构1、术语：树、子树、根结点、结点的度、叶结点、树的度、结点的子结点、结点的父结点、结点的层次、树的深度（高）、森林。

2、二叉树： 2.1二叉树不属于“树”。

2.2 二叉树的性质：①在二叉树的第i 层上至多有2i -1个结点（i ≥1）②深度为K 的二叉树至多有2k-1个结点（k ≥1） ③对任何一棵二叉树，如叶结点的个数为n 0，2度结点个数为n 2则n 0＝n 2+1 说明：分支数为B ，二叉树的结点总数为n =n 0+n 1+ n 2 ∵B =n -1(从结点的头上看) B =n 1+2n 2（从结点的下方看） ∴n -1=n 1+2n 2即n 0+n 1+n 2-1=n 1+2n 2 ∴n 0＝n 2+13、二叉树的存储结构：s t r u c t n o d e{c h a r d a t a ;s t r u c t n o d e *l c h i l d ; s t r u c t n o d e *r c h i l d ; }4、树转换为二叉树：（右链为兄弟） A BC E A B CDE AB C DE F二、遍历二叉树1、规则：1.1先序：打印，遍历左子树，遍历右子树。

A ，B ，D ，C ，E ，F 1.2中序：遍历左子树，打印，遍历右子树。

D ，B ，A ，E ，C ，F 1.3后序：遍历左子树，遍历右子树，打印。

D ，B ，E ，F ，C ，Aa*b-c 此式可画成一个二叉树，如左：先序： -*abc 中序： a*b-c后序： ab*c-3、程序： 3.1先序： preorder(p)struct node *p {if (p){printf(“%c,”,p->data); preorder (p->lchild); preorder(p->rchild); } }3.2中序： …… { preorder (p->lchild);printf(“%c,”,p->data); preorder(p->rchild); } ……3.3后序： ……RC E F H K R ABCDEFGHK{ preorder (p->lchild);preorder(p->rchild);printf(“%c,”,p->data);}……4、求已知二叉树上的叶结点个数：4.1思路：遍历二叉树，如遇到叶结点，则记数器增值。

二叉树的建立方法总结

⼆叉树的建⽴⽅法总结之前已经介绍了⼆叉树的四种遍历(如果不熟悉)，下⾯介绍⼀些⼆叉树的建⽴⽅式。

⾸先需要明确的是，由于⼆叉树的定义是递归的，所以⽤递归的思想建⽴⼆叉树是很⾃然的想法。

1. 交互式问答⽅式这种⽅式是最直接的⽅式，就是先询问⽤户根节点是谁，然后每次都询问⽤户某个节点的左孩⼦是谁，右孩⼦是谁。

代码如下(其中字符'#'代表空节点)：#include <cstdio>#include <cstdlib>using namespace std;typedef struct BTNode *Position;typedef Position BTree;struct BTNode{char data;Position lChild, rChild;};BTree CreateBTree(BTree bt, bool isRoot){char ch;if (isRoot)printf("Root: ");fflush(stdin); /* 清空缓存区 */scanf("%c", &ch);fflush(stdin);if (ch != '#'){isRoot = false;bt = new BTNode;bt->data = ch;bt->lChild = NULL;bt->rChild = NULL;printf("%c's left child is: ", bt->data);bt->lChild = CreateBTree(bt->lChild, isRoot);printf("%c's right child is: ", bt->data);bt->rChild = CreateBTree(bt->rChild, isRoot);}return bt;}int main(){BTree bt;bt = CreateBTree(bt, true);LevelOrderTraversal(bt); /* 层序遍历 */return0;}2. 根据先序序列例如输⼊序列ABDH##I##E##CF#J##G##（#表⽰空），则会建⽴如下图所⽰的⼆叉树思路和第⼀种⽅式很相似，只是代码实现细节有⼀点区别，这⾥给出创建函数BTree CreateBTree(){BTree bt = NULL;char ch;scanf("%c", &ch);if (ch != '#'){bt = new BTNode;bt->data = ch;bt->lChild = CreateBTree();bt->rChild = CreateBTree();}return bt;}3. 根据中序序列和后序序列和⽅式⼆不同的是，这⾥的序列不会给出空节点的表⽰，所以如果只给出先序序列，中序序列，后序序列中的⼀种，不能唯⼀确定⼀棵⼆叉树。

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目，以及二叉树常用运算。

问题分析：二叉树树型结构是一类重要的非线性数据结构，对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义，所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题，我觉得应该：1、建立二叉树；2、通过递归方法来遍历（先序、中序和后序）二叉树；3、通过队列应用来实现对二叉树的层次遍历；4、借用递归方法对二叉树进行一些基本操作，如：求叶子数、树的深度宽度等；5、运用广义表对二叉树进行广义表形式的打印。

算法规定：输入形式：为了方便操作，规定二叉树的元素类型都为字符型，允许各种字符类型的输入，没有元素的结点以空格输入表示，并且本实验是以先序顺序输入的。

输出形式：通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印，再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能：实现对二叉树的先序、中序和后序遍历，层次遍历。

计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找，对二叉树的某个结点进行删除。

测试数据：输入一：ABC□□DE□G□□F□□□（以□表示空格）,查找5,删除E预测结果：先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A（B（C,D（E（,G）,F）））叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5，成功，查找的元素为E删除E后，以广义表形式打印A（B（C,D（,F）））输入二：ABD□□EH□□□CF□G□□□（以□表示空格）,查找10,删除B预测结果：先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A（B(D,E(H)),C(F(,G))）叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10，失败。

【数据结构】二叉树的实现

【数据结构】二叉树的实现//-------------------第一部分-----------------#include <stdio.h>typedef char TElemType;//建立结点typedef struct BiTree{TElemType data;struct BiTree *lchild,*rchild;}BiTree;//-------------------第二部分------------------//1、二叉树的建立：先序建立二叉树，//在创建完成二叉树之后，需要把根节点返回来，设置一个整型的临时变量//设置这个变量的目的就是为了返回根节点BiTree *CreateBiTree(BiTree *BT,int itemp){TElemType ch;BiTree *T1;//先申请一个节点T1 = (BiTree *)malloc(sizeof(BiTree));//如果失败，退出if(!T1)exit(1);//如果输入二叉树元素是“#”，说明这个元素是空的scanf("%c",&ch);if(ch !='#'){//将ch值存入新申请的节点中，新申请的节点，左右子树全为空T1->data = ch;T1->lchild = NULL;T1->rchild = NULL;//如果是根节点（只有一个），将申请的节点赋值给BTif(itemp == 0)BT = T1;//如果是左子树，将申请的节点赋值给BT的左孩子if(itemp == 1)BT->lchild = T1;//如果是右子树，将申请的节点赋值给BT的右孩子if(itemp == 2)BT->rchild = T1;//（2）创建左子树,整型变量为1，代表左子树CreateBiTree(T1,1);//（3）创建右子树,整型变量为2，代表右子树CreateBiTree(T1,2);}//返回根节点return BT;}//2、二叉树的遍历：三种方式：先序遍历、中序遍历、后序遍历//先序遍历口诀：根左右//中序遍历口诀：左根右//后续遍历口诀：左右根//（1）先序遍历二叉树void Pre_OrderTraverse(BiTree *T){//如果树存在if(T != NULL){//先输出根节点printf("%c ",T->data);//再输出左子树Pre_OrderTraverse(T->lchild);//最后输出右子树Pre_OrderTraverse(T->rchild);}}//（2）中序遍历二叉树void In_OrderTraverse(BiTree *T){//如果树存在if(T != NULL){//先遍历左子树In_OrderTraverse(T->lchild);//再输出根节点printf("%c ",T->data);//最后输出右子树In_OrderTraverse(T->rchild);}}//（3）后序遍历二叉树void Post_OrderTraverse(BiTree *T){//如果树存在if(T != NULL){//先输出左子树Post_OrderTraverse(T->lchild);//再输出右子树Post_OrderTraverse(T->rchild);//最后输出根节点printf("%c ",T->data);}}//-----------------------第三部分------------------------void main(){BiTree BT,*T;//1、以先序遍历的方式创建二叉树printf("先序建立二叉树,（每个结点为一个字符，空节点为“#”）：\n");T = CreateBiTree(&BT,0);printf("-----------------------创建树成功！-------------------------\n");printf("\n");printf("\n");printf("\n");//2、以先序遍历的方式输出二叉树printf("先序建立二叉树的结果是：\n");Pre_OrderTraverse(T);printf("\n");printf("\n");printf("\n");//3、以中序遍历的方式输出二叉树printf("中序建立二叉树的结果是：\n");In_OrderTraverse(T);printf("\n");printf("\n");printf("\n");//4、以后序遍历的方式输出二叉树printf("后序建立二叉树的结果是：\n");Post_OrderTraverse(T);printf("\n");}。

设计以先序遍历的顺序建立二叉树的二叉链表存储结构的算法

设计以先序遍历的顺序建立二叉树的二叉链表存储结构的算法一、算法简介二叉树是一种重要的树形结构，它的建立方式有多种，其中一种是按照先序遍历的顺序建立二叉树。

这种方式需要将先序遍历序列和二叉树的存储结构相结合，采用二叉链表存储结构。

具体流程是按照先序遍历序列的顺序依次创建二叉树的各个节点，同时使用二叉链表结构保存每个节点的数据和指针信息。

二、算法实现算法的实现主要包括初始化二叉树、创建节点、建立二叉树等步骤，下面对这些步骤进行详细描述。

1. 初始化二叉树初始化二叉树需要创建一个根节点，同时将根节点的左右指针指向NULL，表示二叉树为空。

2. 创建节点创建节点需要通过输入元素数据来创建，同时节点的左右指针也需要初始化为NULL。

3. 建立二叉树建立二叉树是按照先序遍历序列来实现的，具体流程如下：（1）读入当前节点的元素数据，创建节点，并将其作为当前节点。

（2）判断当前节点的元素数据是否为结束符号（这里结束符号可以指定），如果是，则返回NULL。

（3）递归创建当前节点的左子树，将左子树的根节点赋值给当前节点的左指针。

（4）递归创建当前节点的右子树，将右子树的根节点赋值给当前节点的右指针。

（5）返回当前节点。

三、算法优化虽然上述算法实现简单明了，但它有一个缺点，即无法处理空节点的情况，如果输入的先序遍历序列中存在空节点，那么该算法就无法建立正确的二叉树了。

因此，可以在输入的先序遍历序列中使用一个特殊的符号（如#）表示空节点，在建立节点时，如果遇到该符号，则将该节点的指针设置为NULL即可。

四、算法总结按照先序遍历的顺序建立二叉树是一种基于二叉链表存储结构的建树方式。

它通过递归的方式构建整个二叉树，同时为了处理空节点的情况，还需要对输入的先序遍历序列进行特殊处理。

该算法的效率较高，适用于对先序遍历序列已知的情况下建立二叉树。

关于树的各种C语言代码

集合了树的各种算法，已经运行过，本人亲自所写，先序，后序，等全包括#include<stdio.h>#include<malloc.h>#define Max 100typedef int Status;typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int count;Status CreatBiTree(BiTree *bt) /*1.按先序遍历序列创造二叉树的二叉链表*/ {char ch;getchar();scanf("%c",&ch);if (ch == ' '){*bt = NULL;}else{*bt = (BiTree)malloc(sizeof(BiTNode));(*bt)->data = ch;printf("\n\t请输入%c结点的左孩子:",(*bt)->data);CreatBiTree(&((*bt)->lchild));printf("\n\t请输入%c结点的右孩子:",(*bt)->data);CreatBiTree(&((*bt)->rchild));}return 1;}void PreOrder(BiTree bt) /*2.先序遍历二叉树*/{if (bt != NULL){printf("%c\n",bt->data);PreOrder(bt->lchild);PreOrder(bt->rchild);}}void InOrder(BiTree bt) /*3.中序遍历二叉树*/{if (bt != NULL){InOrder(bt->lchild);printf("%c\n",bt->data);InOrder(bt->rchild);}}void PostOrder(BiTree bt) /*4.后序遍历二叉树*/{if (bt != NULL){PostOrder(bt->lchild);PostOrder(bt->rchild);printf("%c\n",bt->data);}}void PreOrderLeaf(BiTree bt) /*5.输出所有的叶子结点*/{if (bt != NULL){if ((bt->lchild == NULL) && (bt->rchild == NULL)){printf("%c\n",bt->data);}PreOrderLeaf(bt->lchild);PreOrderLeaf(bt->rchild);}}Status Leaf(BiTree bt) /*6.统计叶子结点数目，即度为零的结点数目*/ {if (bt == NULL){count = 0;}else if ((bt->lchild == NULL) && (bt->rchild == NULL)){count = 1;}else{count = Leaf(bt->lchild) + Leaf(bt->rchild);}return count;}void Degree1Node(BiTree bt) /*7.输出度为一的结点*/{if (bt != NULL){if (((bt->lchild != NULL) || (bt->rchild != NULL))&& (!((bt->lchild != NULL) && (bt->rchild != NULL)))) {printf("%c\n",bt->data);}Degree1Node(bt->lchild);Degree1Node(bt->rchild);}}void Degree2Node(BiTree bt) /*8.输出度为二的结点*/{if ( bt != NULL){if ((bt->lchild != NULL) && (bt->rchild != NULL)){printf("%c\n",bt->data);}Degree2Node(bt->lchild);Degree2Node(bt->rchild);}}Status CountNode(BiTree bt) /*9.统计二叉树中结点的总数*/{if (bt == NULL){return 0;}else{count++;CountNode(bt->lchild);CountNode(bt->rchild);return count;}}Status TreeDepth(BiTree bt) /*10.求二叉树的深度*/{int ldep, rdep;if (bt == NULL){return 0;}else{ldep = TreeDepth(bt->lchild);rdep = TreeDepth(bt->rchild);if (ldep > rdep){return (ldep +1);}else{return (rdep + 1);}}}void PrintTree(BiTree bt, int nlayer) /*11.按树状打印二叉树*/ {if (bt == NULL) /*如果是空则直接退出函数*/{return;}PrintTree(bt->rchild,nlayer + 1);for ( int i = 0; i < nlayer; i++){printf("----");}printf("%c\n",bt->data);PrintTree(bt->lchild,nlayer + 1);}void PreOrderTree(BiTree bt) /*12.非递归先序遍历*/BiTree Stack[Max];BiTree p = bt;int top = 0;while (p != NULL || top != 0){if (p != NULL){printf("%c",p->data);top++;Stack[top] = p;p = p->lchild;}else{p = Stack[top];top--;p = p->rchild;}}}void InOrderTree(BiTree bt) /*13.非递归中序遍历*/ {BiTree Stack[Max];BiTree p = bt;int top = 0;do{while (p != NULL){top++;Stack[top] = p;p = p->lchild;}if (top != 0){p = Stack[top];top--;printf("%c",p->data);p = p->rchild;}}while ((p != NULL) || (top != 0));void PostOrderTree(BiTree bt) /*14.非递归后序遍历*/ {BiTree p, q;int top = 0;BiTree Stack[Max];q = NULL;p = bt;while ((p != NULL) || (top != 0)){while (p != NULL){top++;Stack[top] = p;p = p->lchild;}if (top > 0){p = Stack[top];if ((p->rchild == NULL) || (p->rchild == q)){printf("%c",p->data);q = p;p = NULL;top--;}else{p = p->rchild;}}}}void LayerOrder(BiTree bt) /*15.层次遍历*/{int front,rear;BiTree Q[Max];front = 0;rear = front;BiTree r, s, p;r = s = p = bt;if (p == NULL) return;Q[rear] = p;rear++;while (front != rear){s = r = Q[front];printf("%c",Q[front]->data);front++;if (r->lchild){Q[rear] = r->lchild;rear++;}if (s->rchild){Q[rear] = s->rchild;rear++;}}}int main(){BiTree bt;int choice;int i,j,k;int nlayer = 1;printf("请用数字选择操作：\n");printf("1.按先序序列创建二叉树（二叉链表）\n");printf("2.递归先序遍历二叉树\n");printf("3.递归中序遍历二叉树\n");printf("4.递归后序遍历二叉树\n");printf("5.输出叶子结点（即度为零的结点）\n");printf("6.统计叶子结点数目\n");printf("7.输出度为一的结点\n");printf("8.输出度为二的结点\n");printf("9.统计二叉树中结点总数\n");printf("10.求二叉树的高度（即深度）\n");printf("11.按树状打印二叉树\n");printf("12.非递归先序遍历二叉树\n");printf("13.非递归中序遍历二叉树\n");printf("14.非递归后序遍历二叉树\n");printf("15.层次遍历二叉树\n");printf("0.则退出\n");while (1){printf("请输入你要执行的操作(0-15):");scanf("%d",&choice);if (choice == 0){break;}else switch (choice){case 1 : printf("\n请输入按先序建立二叉树的结点序列：");printf("\n说明：逐个输入，输入空格代表后继结点为空，按回车输入下一个结点。

二叉树的建立及凹入表打印

先序递归建立二叉树班级2012211313姓名:胡卓学号:2012211468 姓名:郭志刚学号:2012211475 分工情况:郭志刚BiTree CreateBiTree(BiTree& T)//先序递归创建二叉树 int main() 胡卓void Print(BiTree& T,int t) int LEAF(BiTree& T)//计算叶子节点完成日期:2013-11-6问题描述:1）用先序递归过程建立二叉树 (存储结构：二叉链表)输入数据按先序遍历所得序列输入，当某结点左子树或右子树为空时，输入‘*’号，如输入abc**d**e**得到的二叉树为：ea dbc（选做：由二叉树的先序序列和中序序列建立一棵二叉树。

）2）编写递归算法，计算二叉树中叶子结点的数目。

3）按凹入表方式输出该二叉树。

算法思想:定义二叉树的数据结构类型typedef struct BiTNode//{char data;struct BiTNode*lchild,*rchild;//左右子树}BiTNode,*BiTree;1.先序递归创建二叉树BiTree CreateBiTree(BiTree& T)｛T=(BiTree)malloc(sizeof(BiTNode));T->data='\0';char ch;scanf("%c",&ch);if(ch!='*'){T->data=ch;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}else if(ch=='*')return NULL;if((T->lchild==NULL&&T->rchild==NULL)||(T->lchild==NULL&&T->rchild->data!='\0') ||(T->lchild->data!='\0'&&T->rchild==NULL)||(T->lchild->data!='\0'&&T->rchild-> data!='\0'))return T;}2.计算叶子节点int LEAF(BiTree& T){if(T->lchild==NULL&&T->rchild==NULL)return 1;else if(T->lchild==NULL&&T->rchild->data!='\0')return LEAF(T->rchild);else if(T->lchild->data!='\0'&&T->rchild==NULL)return LEAF(T->lchild);elsereturn (LEAF(T->lchild)+LEAF(T->rchild));}3.凹入表打印二叉树void Print(BiTree& T,int t){int i;if(T){Print(T->rchild,t+5);for(i=0;i<t;i++){printf(" ");}printf("%5c\n",T->data);Print(T->lchild,t+5);}}4.主函数int main(){BiTree T;printf("*******************************************\n");printf("****************欢迎打印二叉树*************\n");printf("*******************************************\n");printf("请按先序遍历所得数据输入(当某节点是叶子节点时用'*'表示)：\n"); T=CreateBiTree(T);printf("叶子节点的个数是: ");printf(" %d\n",LEAF(T));printf("打印该二叉树结构后的结果为:\n");Print(T,5);system("pause");}设计描述:源程序:#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define Maxsize 100#define OVERFLOW -1#define ERROR 0int pi=0;typedef struct BiTNode//定义二叉树的数据结构类型{char data;struct BiTNode*lchild,*rchild;//左右子树}BiTNode,*BiTree;BiTree CreateBiTree(BiTree& T)//先序递归创建二叉树{T=(BiTree)malloc(sizeof(BiTNode));T->data='\0';char ch;scanf("%c",&ch);if(ch!='*'){T->data=ch;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}else if(ch=='*')return NULL;if((T->lchild==NULL&&T->rchild==NULL)||(T->lchild==NULL&&T->rchild->data!='\0') ||(T->lchild->data!='\0'&&T->rchild==NULL)||(T->lchild->data!='\0'&&T->rchild-> data!='\0'))return T;}int LEAF(BiTree& T)//计算叶子节点{if(T->lchild==NULL&&T->rchild==NULL)return 1;else if(T->lchild==NULL&&T->rchild->data!='\0')return LEAF(T->rchild);else if(T->lchild->data!='\0'&&T->rchild==NULL)return LEAF(T->lchild);elsereturn (LEAF(T->lchild)+LEAF(T->rchild));}void Print(BiTree& T,int t){int i;if(T){Print(T->rchild,t+5);for(i=0;i<t;i++){printf(" ");}printf("%5c\n",T->data);Print(T->lchild,t+5);}}int main(){BiTree T;printf("*******************************************\n");printf("****************欢迎打印二叉树*************\n");printf("*******************************************\n");printf("请按先序遍历所得数据输入(当某节点是叶子节点时用'*'表示)：\n"); T=CreateBiTree(T);printf("叶子节点的个数是: ");printf(" %d\n",LEAF(T));printf("打印该二叉树结构后的结果为:\n");Print(T,5);system("pause");}测试结果:用户使用说明:请按先序遍历所得数据输入（当某节点是叶子时用‘*’表示）：（输入先序遍历序列）叶子节点的个数是：（显示叶子节点的个数）打印该二叉树结构后的结果为：（显示二叉树结构直观凹入图）心得体会:通过对二叉树的学习与同学之间的交流，我对二叉树及其递归建立和遍历有了更加深入的了解，感觉学到了很多东西，感受到了学习的乐趣。

二叉树实验报告

实验报告实验题目二叉树需求分析程序的功能从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立），并采用递归算法对其进行遍历（先序、中序、后序），将遍历结果打印输出。

输入的形式ABCффDEфGффFффф（其中ф表示空格字符）输出的形式先序：ABCDEGF中序：CBEGDFA后序：CGBFDBA概要设计给出所用抽象数据类型的逻辑定义CreateTree(&bt); //创建二叉树PreOrder(bt); //先序遍历InOrder(bt); //中序遍历PostOrder(bt); //后序遍历画出主程序的流程框图画出各模块之间的调用关系图。

Main()Preorder() InOrder() PastOrder()详细设计（1）确定存储结构，并给出所用抽象数据类型的数据结构定义void PreOrder(BiTree root){if(root!=NULL){printf("%c",root->data);PreOrder(root->Lchild);PreOrder(root->Rchild);}}void InOrder(BiTree root){if(root!=NULL){ InOrder(root->Lchild );printf("%c",root->data);InOrder(root->Rchild);}}void PostOrder(BiTree root){if(root!=NULL){ PostOrder(root->Lchild);PostOrder(root->Rchild);printf("%c",root->data);}}给出主程序的伪码算法Main(){创建二叉树先序遍历中序遍历后序遍历}调试分析核心算法改进设想使用非递归算法测试结果列出典型输入及对应的输出结果。

前序序列和后续序列确定二叉树

前序序列和后续序列确定⼆叉树⼆叉树：已知前序与后序建树那么我们换⼀种思考⽅式，我们先来看看先序与后序序列的排布规律。

以下⾯这棵树来举例：其先序序列为： 1 2 3 4 6 7 5后序序列为：2 6 7 4 5 3 1⾸先我们要知道：先序序列遍历顺序是：根结点-左⼦树-右⼦树后序序列遍历顺序是：左⼦树-右⼦树-根结点很明显，我们可以看出结点在先、后序列中的排布有以下这些特征：【1】、在先序序列中，根结点在⼦树中的结点前⾯，在后序序列中，根结点在⼦树中的结点后⾯。

【2】、以任⼀节点为根结点时，其⼦树在先序后序序列中排布都是先左⼦树后右⼦树，⽽根结点排在最后。

那么，反过来思考，已知这个先序与后序序列所确定的树是唯⼀的吗？进⼀步推⼴：怎么通过先序与后序序列判断是否存在唯⼀的树呢？现在，我们来⼀步步分析已知先序与后序的建树过程：①、根据特征【1】可知：根结点为先序序列第⼀个节点以及后序序列最后⼀个结点，因此根结点为1。

②、先序序列中第⼆个结点为2，其在后序序列中的位置是第⼀个，那么根据特征【2】我们可以知道结点2是没有⼦树的，⽽且结点2要么在根结点的左⼦树，要么在右⼦树。

假设结点2在右⼦树，那么由特征【2】可知根结点1没有左⼦树，⽽且先序序列中结点2后⾯的结点全部为结点2的⼦树上的结点。

再看后序序列，由特征【2】可知，结点2后⾯的结点不可能是其⼦树上的结点。

因此，假设显然与已知⽭盾。

这样，我们⼜知道结点2是结点1的左孩⼦，且结点2没有⼦结点。

③、先序序列第三个位置上的结点为3，该结点在后序序列中排倒数第⼆个。

由②可知，结点3必然是根结点1的右孩⼦。

④、先序序列第四个位置上的结点为4，该结点在后序序列中排第四个。

因为结点4在先序序列中排在结点3后⾯，⼜因为结点3是根结点1的右孩⼦，所以结点4只可能在结点3的⼦树上。

结点3的⼦树可能出现的情况是：只有左⼦树，只有右⼦树，左右⼦树都有。

因为在后序序列中，结点4左边是结点6、7，右边是结点5。

二叉树的建立和遍历实验报告

二叉树的建立和遍历实验报告一、引言（100字）二叉树是一种常见的数据结构，它由根节点、左子树和右子树组成，具有递归性质。

本次实验的目的是了解二叉树的建立过程和遍历算法，以及熟悉二叉树的相关操作。

本实验采用C语言进行编写。

二、实验内容（200字）1.二叉树的建立：通过输入节点的值，逐个建立二叉树的节点，并通过指针连接起来。

2.二叉树的遍历：实现二叉树的三种常用遍历算法，即前序遍历、中序遍历和后序遍历。

三、实验过程（400字）1.二叉树的建立：首先，定义二叉树的节点结构，包含节点值和指向左右子树的指针；然后，通过递归的方式，依次输入节点的值，创建二叉树节点，建立好节点之间的连接。

2.二叉树的前序遍历：定义一个函数，实现前序遍历的递归算法，先输出当前节点的值，再递归遍历左子树和右子树。

3.二叉树的中序遍历：同样，定义一个函数，实现中序遍历的递归算法，先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树。

4.二叉树的后序遍历：同样，定义一个函数，实现后序遍历的递归算法，先递归遍历左子树和右子树，再输出当前节点的值。

四、实验结果（300字）通过实验，我成功建立了一个二叉树，并实现了三种遍历算法。

对于建立二叉树来说，只要按照递归的思路，先输入根节点的值，再分别输入左子树和右子树的值，即可依次建立好节点之间的连接。

建立好二叉树后，即可进行遍历操作。

在进行遍历算法的实现时，我首先定义了一个函数来进行递归遍历操作。

在每一次递归调用中，我首先判断当前节点是否为空，若为空则直接返回；若不为空，则按照特定的顺序进行遍历操作。

在前序遍历中，我先输出当前节点的值，再递归遍历左子树和右子树；在中序遍历中，我先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树；在后序遍历中，我先递归遍历左子树和右子树，再输出当前节点的值。

通过运行程序，我成功进行了二叉树的建立和遍历，并得到了正确的结果。

可以看到，通过不同的遍历顺序，可以获得不同的遍历结果，这也是二叉树遍历算法的特性所在。

二叉树作业

二叉树作业专业班级：姓名：学号：代码清单：1-2页：结构体定义，包括二叉链表，队列，以及队列的一些常用函数：入队出对队列销毁2-7页：二叉树的操作函数，依次为初始化二叉树先序建立二叉树先序遍历二叉树输出（3）求树的深度求树的结点数求树的度为0，1 ，2的节点数（4）在树中查找X交换二叉树的左右子树（5）复制二叉树判断两个树是否相似（6）求树的最大宽度（7）8页：main函数，测试。

9页：截屏运行结果。

源代码：#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedefint Status;//二叉链表结构体typedefstructBiTNode{int data;structBiTNode *lchild,*rchild;}BiTNode,*BiTree;typedefBiTreeQElemType;//队列结构typedefstructQNode{QElemType data;QNode *next;}*QueuePtr;structLinkQueue{QueuePtrfront,rear; // 队头、队尾指针};//用到的队列函数Status InitQueue(LinkQueue&Q){ // 构造一个空队列Qif(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))exit(OVERFLOW);Q.front->next=NULL;return OK;}Status DestroyQueue(LinkQueue&Q){ // 销毁队列Q(无论空否均可)while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue Q){ // 若Q为空队列,则返回TRUE,否则返回FALSEif(Q.front==Q.rear)return TRUE;elsereturn FALSE;}Status EnQueue(LinkQueue&Q,QElemType e){ // 插入元素e为Q的新的队尾元素QueuePtr p;if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}Status DeQueue(LinkQueue&Q,QElemType&e){ // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR QueuePtr p;if(Q.front==Q.rear)return ERROR;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return OK;}//初始化二叉树Status InitBiTree(BiTree&T){T=NULL;return OK;}//先序建立二叉树void CreateBiTree(BiTree&T){intch;scanf("%d",&ch);if(ch==0)T=NULL;else{T=(BiTree)malloc(sizeof(BiTNode));if(!T)exit(OVERFLOW);T->data=ch; // 生成根结点CreateBiTree(T->lchild); // 构造左子树CreateBiTree(T->rchild); // 构造右子树}}//先序遍历二叉树，输出二叉树void PreOrderTraverse(BiTreeT,void(*Visit)(int)){if(T){Visit(T->data); // 先访问根结点PreOrderTraverse(T->lchild,Visit); // 再递归先序遍历左子树PreOrderTraverse(T->rchild,Visit); // 最后递归先序遍历右子树}}void visit(int c){printf("%d ",c);}//求树的深度intBiTreeDepth(BiTree T){inti,j;if(!T)return 0;if(T->lchild)i=BiTreeDepth(T->lchild);elsei=0;if(T->rchild)j=BiTreeDepth(T->rchild);elsej=0;return i>j?i+1:j+1;//一直往下层遍历，有左孩子或有右孩子则深度加1}//求树的结点数intBiTreeNodeNum(BiTreeT,int&i)//递归遍历每一个结点，每次递归调用函数时i++ {i++;if(!T)return 0;if(T->lchild){BiTreeNodeNum(T->lchild,i);}if(T->rchild){BiTreeNodeNum(T->rchild,i);}return OK;}//求树的度为0，1 ，2的节点数intBiTreeFleaNum(BiTreeT,int&i,int&j,int& k)//原理同求树的结点{if(!T){return 0;}if(!(T->lchild || T->rchild)){i++;}if(T->lchild){if(T->rchild)j++;else k++;BiTreeFleaNum(T->lchild,i,j,k);}if(T->rchild){if(!T->lchild)k++;BiTreeFleaNum(T->rchild,i,j,k);}return OK;}//在树中查找X，返回数据为X的结点指针BiTree Point(BiTreeT,int x) //利用队列遍历结点，找到X就结束遍历{LinkQueue q;QElemType a;if(T){InitQueue(q);EnQueue(q,T);while(!QueueEmpty(q)){DeQueue(q,a);if(a->data==x)return a;if(a->lchild)EnQueue(q,a->lchild);if(a->rchild)EnQueue(q,a->rchild);}}return NULL;}//交换二叉树的左右子树void exchange(BiTreert) //temp为过渡结点，用于左右孩子交换，从根结点左右孩子开始交换，依次往下遍历{BiTree temp = NULL;if(rt->lchild == NULL &&rt->rchild == NULL) //空树就不需要交换，直接返回return;else{temp = rt->lchild;rt->lchild = rt->rchild;rt->rchild = temp;}if(rt->lchild)exchange(rt->lchild);if(rt->rchild)exchange(rt->rchild);}//复制二叉树BiTreeGetTreeNode(intitem,BiTreelptr,BiTreerptr)//用来复制结点{BiTree T;T=new BiTNode;T->data=item;T->lchild=lptr;T->rchild=rptr;return T;}BiTreeCopyTree(BiTree T)//遍历每一个结点，将结点数据，左右孩子指针传到GetTreeNode函数，将结点复制，返回结点指针{BiTreenewlchild,newrchild,newnode;if(!T) return NULL;if(T->lchild)newlchild=CopyTree(T->lchild);else newlchild=NULL;if(T->rchild)newrchild=CopyTree(T->rchild);else newrchild=NULL;newnode=GetTreeNode(T->data,newlchild,newrchild);return newnode;}//判断两个树是否相似int like(BiTree b1,BiTree b2)//递归调用本身{int like1,like2;if(b1==NULL&&b2==NULL)return 1; //两个为空子树、相似else if(b1==NULL||b2==NULL)return 0; //两个中某一个为空子树、不相似else{like1=like(b1->lchild,b2->lchild);like2=like(b1->rchild,b2->rchild);return(like1&&like2);}}//求树的最大宽度intFindMaxWidth(BiTreebt)//利用模拟数组队列求最大宽度{BiTree p;if (bt==NULL)return (0); //空二叉树宽度为0else{BiTree Q[10]; //Q是队列，元素为二叉树结点指针，容量最大为10int front=1,rear=1,last=1;//front队头指针,rear队尾指针,last同层最右结点在队列中的位置int temp=0, maxw=0; //temp记局部宽度, maxw记最大宽度Q[rear]=bt; //根结点入队列while(front<=last){p=Q[front++];temp++; //同层元素数加1if (p->lchild!=NULL) Q[++rear]=p->lchild;if (p->rchild!=NULL) Q[++rear]=p->rchild;if (front>last) //一层结束，{last=rear; if(temp>maxw) maxw=temp; //last指向下层最右元素, 更新当前最大宽度temp=0;}}return (maxw);}}void main (){BiTreemt;inti=0,j=0,k=0,h=0,l=0;printf("请按先序输入二叉树结点：（0代表空表）\n");CreateBiTree(mt);printf("先序输出链表数据为：\n");PreOrderTraverse(mt,visit);printf("\n结点个数为: ");BiTreeNodeNum(mt,i);printf("%d \n",i);printf("结点的度统计: \n");BiTreeFleaNum(mt,l,j,k);printf("度为0 的结点个数为：%d\n度为1 的结点个数为：%d\n度为2 的结点个数为：%d ",l,k,j);h=BiTreeDepth(mt);printf("\n树的深度为：%d \n",h);h=FindMaxWidth(mt);printf("树的最大宽度为：%d \n",h);BiTree mt2;mt2=CopyTree(mt);printf("将二叉树mt复制到mt2中，先序输出mt2：\n");PreOrderTraverse(mt2,visit);BiTree mt3;printf("\n请按先序输入二叉树结点，构造二叉树mt3：（0代表空表）\n");CreateBiTree(mt3);i=like(mt,mt2);j=like(mt,mt3);if(i)printf("\nmt与mt2相似");elseprintf("\nmt与mt2不相似");if(j)printf("\nmt与mt3相似");elseprintf("\nmt与mt3不相似");printf("\n将树的左右子树交换之后先序输出结果为：\n");exchange(mt);PreOrderTraverse(mt,visit);printf("\n请输入要查找的一个结点：");scanf("%d",&i);BiTree a;a=Point(mt,i);if(a==NULL)printf("\n当前树中没有此元素！");elseprintf("\n要找的元素指针所指数据为：%d \n",a->data);}截屏运行结果：实验数据分析：。

二叉树的先序,中序,后序遍历的递归工作栈的关系

二叉树的先序,中序,后序遍历的递归工作栈的关系在计算机科学中，二叉树是一种非常重要的数据结构，它在很多算法和数据处理中都有着广泛的应用。

而二叉树的先序、中序、后序遍历以及它们与递归和工作栈的关系更是程序员面试中常见的问题。

本文将从深度和广度两个方面，按照先序、中序、后序的顺序逐步展开对这个主题的探讨。

一、先序遍历先序遍历是指先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。

在实际的计算机算法中，我们可以使用递归或者栈来实现先序遍历。

1.1 递归实现当我们使用递归来实现先序遍历时，可以很容易地写出下面这段代码：```pythondef preorderTraversal(root):if not root:return []return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)```这段代码非常简洁明了，但是在实际执行时，会使用工作栈来保存递归中间结果。

因为递归本质上就是一个栈结构，在调用递归函数时，会将当前函数的局部变量和参数压入栈中，直到递归结束，栈中的内容才会依次出栈执行。

1.2 栈实现除了递归之外，我们也可以使用显式栈来实现先序遍历。

这种方法通常会更加高效一些，因为递归会有一定的性能损耗。

栈的实现思路是，我们首先将根节点压入栈中，然后弹出栈顶节点并访问它，接着先将右子节点压入栈中，再将左子节点压入栈中。

重复上述操作直到栈为空。

这样就可以保证先访问根节点，再访问左子树，最后访问右子树，符合先序遍历的要求。

二、中序遍历中序遍历是指先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。

中序遍历同样可以用递归或者显式栈来实现。

2.1 递归实现递归实现中序遍历同样非常简单：```pythondef inorderTraversal(root):if not root:return []return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right)```在这个递归函数中，同样使用了递归的工作栈来保存中间结果。

树与二叉树经典题C++算法

树和二叉树1 按先序遍历的扩展序列建立一棵二叉树的存储结构。

设计思想：先序遍历为：先访问根节点，先序遍历左子数，先序遍历右子数完整代码见附件。

伪代码为：bool BITREE::CreateBiTree(BiTree &T){ /*先序序列建立二叉树*/char ch;scanf("%c",&ch);if (ch=='*')T = NULL;else {if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))return ERROR;T->data = ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}2 分别实现二叉树先序、中序、后序遍历的递归算法。

设计思想：先序遍历为：访问根节点，先序遍历左子数，先序遍历右子数中序遍历为：中序遍历左子数，访问根节点，中序遍历右子数后序遍历为：后序遍历左子数，后序遍历右子数，访问根节点完整代码见附件。

伪代码为：Status BITREE::PreOrderTraverse(BiTree T, Status(*Visit)(TElemType)) { /*先序遍历二叉树的递归算法*/if (T){if(Visit(T->data))if(PreOrderTraverse(T->lchild, Visit))if(PreOrderTraverse(T->rchild, Visit))return OK;return ERROR;}elsereturn OK;}Status BITREE::InOrderTraverse(BiTree T, Status(*Visit)(TElemType)) { /*中序遍历二叉树的递归算法*/if(T){if(InOrderTraverse(T->lchild, Visit))if(Visit(T->data))if(InOrderTraverse(T->rchild, Visit))return OK;return ERROR;}else return OK;}Status BITREE::PostOrderTraverse(BiTree T, Status(*Visit)(TElemType)) { /*后序遍历二叉树的递归算法*/if(T){if(PostOrderTraverse(T->lchild, Visit))if(PostOrderTraverse(T->rchild, Visit))if(Visit(T->data))return OK;return ERROR;}else return OK;}3 实现二叉树中序遍历的非递归算法。

二叉树先序遍历c语言

二叉树先序遍历c语言在计算机科学的领域中，二叉树是一种非常重要且常用的数据结构。

它由节点组成，每个节点可以存储一个值，并且最多有两个子节点，分别称为左子节点和右子节点。

二叉树可以用来解决许多实际问题，例如在编写搜索算法时，可以使用二叉树来快速定位目标值。

同时，二叉树还可以用于构建更复杂的数据结构，例如堆和红黑树。

在二叉树中，先序遍历是一种遍历方式。

它的步骤如下：1. 访问根节点。

2. 遍历左子树。

3. 遍历右子树。

下面我们将用C语言来实现二叉树的先序遍历。

首先，我们需要定义一个二叉树节点的结构体，如下所示：```ctypedef struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;} TreeNode;```然后，我们可以通过递归的方式来实现先序遍历函数，代码如下：```cvoid preorderTraversal(TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->val); // 访问根节点preorderTraversal(root->left); // 遍历左子树preorderTraversal(root->right); // 遍历右子树}```在这个递归函数中，我们首先判断根节点是否为空，如果为空则返回。

然后，我们访问根节点的值，并依次递归地遍历左子树和右子树。

接下来，我们可以创建一个二叉树并测试我们的先序遍历函数。

下面是一个简单的示例：```cint main() {TreeNode* root = malloc(sizeof(TreeNode));root->val = 1;TreeNode* node1 = malloc(sizeof(TreeNode));node1->val = 2;TreeNode* node2 = malloc(sizeof(TreeNode));node2->val = 3;root->left = node1;root->right = node2;printf("先序遍历结果：");preorderTraversal(root);printf("\n");return 0;}```在这个示例中，我们创建了一个具有三个节点的二叉树，并调用先序遍历函数进行遍历。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>
typedef struct BiTNode{
char data;
struct BiTNode *lch,*rch;
}BiTNode,*BiTree;
//按先序次序输入二叉树终结点的值（字符,#代表空）
void CreatBiTree(BiTree&T){
char ch;
cout<<"INPut data:"<<endl;
cin>>ch;
if(ch=='#') T=NULL;
else{
if(!(T=new BiTNode)) exit(-2);//对T分配空间若不成功则退出程序
T->data=ch;
CreatBiTree(T->lch);
CreatBiTree(T->rch);
}
return;
}
//按先序输出
void preorder (BiTree &p)//void preorder (BiTree *p)错
//void preorder (BiTree p)、void preorder (BiTree &p)对{
//BiTree p;
//p=T;
if (p!=NULL)
{
cout<<p->data<<"";
preorder(p->lch);
preorder(p->rch);
}
}
//按中序输出
void preorderl (BiTree &p)//void preorder (BiTree *p)错
//void preorder (BiTree p)、void preorder (BiTree &p)对{
//BiTree p;
//p=T;
if (p!=NULL)
{
preorder(p->lch);
cout<<p->data<<"";
preorder(p->rch);
}
}
void main()
{
BiTNode Tree,*T;
//T=&Tree;
CreatBiTree(T);
preorder (T);
cout<<""<<endl;
preorderl (T);
cout<<""<<endl;
return;
}
//总结：+。