C语言实现二叉树的前序、中序、后续遍历(递归法)
二叉树的建立与先序中序后序遍历 求叶子节点个数 求分支节点个数 求二叉树的高度
/*一下总结一些二叉树的常见操作:包括建立二叉树先/中/后序遍历二叉树求二叉树的叶子节点个数求二叉树的单分支节点个数计算二叉树双分支节点个数计算二叉树的高度计算二叉树的所有叶子节点数*/#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节点,它没有右孩子或右孩子已被访问。
C 二叉树创建、前序遍历、中序遍历、后序遍历 的 递归与非递归实现 以及 层次遍历
二叉树创建、前序遍历、中序遍历、后序遍历的递归与非递归实现以及层次遍历二叉树的创建:#include"stdio.h"typedef char ElemType;#define MAXNUM 150/* 二叉树结点定义 */typedef struct BTNode{ElemType data;/* data field */struct BTNode *lchild;struct BTNode *rchild;} BTNode;/* 辅助的二叉树索引数组 */BTNode *p[MAXNUM+1];/* 根据用户输入创建二叉树 *//* 二叉树结点信息:数据域,以及在完全二叉树中的索引值 */BTNode *Create_BiTree(void){BTNode* t =NULL;int i;int j;char ch;printf("\n enter i, ch :");scanf("%d,%c",&i,&ch);while(i != 0 && ch !='#'){BTNode* s =(BTNode*)malloc(sizeof(BTNode)); s->data = ch;s->lchild = s->rchild =NULL;p[i]= s;if( i == 1 )t = s;else{j = i/2;if( i%2 == 0 )p[j]->lchild = s;elsep[j]->rchild = s;}printf("\n enter i, ch :");scanf("%d,%c",&i,&ch);}return t;}int main(void){BTNode* t;t = Create_BiTree();/*preorder(t);printf(" preorder\n");preorder_recursive(t);printf(" preorder_recursive\n");Inorder(t);printf(" Inorder\n");Inorder_recursive1(t);printf(" Inorder_recursive1\n"); Inorder_recursive2(t);printf(" Inorder_recursive2\n");Postorder(t);printf(" Postorder\n");Postorder_recursive(t);printf(" Postorder_recursive\n");LevelOrder(t);printf(" LevelOrder\n");*/getchar();getchar();return 0;}二叉树的前序遍历,递归、非递归的实现:/* 前序遍历的递归实现 */void preorder(BTNode *bt){if(bt){printf("%c ",bt->data);preorder(bt->lchild);preorder(bt->rchild);}}/* 前序遍历的非递归实现 */void preorder_recursive(BTNode *bt){BTNode* p;BTNode* s[MAXNUM+1];/* 辅助的模拟栈 */ int top;p=bt;top=-1;while(p||top !=-1){if(p){printf("%c ",p->data);++top;二叉树的中序遍历,递归、非递归的实现:BTNode* p,*s[MAXNUM+1];int top;p=bt;top=-1;while(p||top !=-1){if(p){++top;s[top]=p;p=p->lchild ;}/*p移向左孩子*/else/*栈非空*/{p=s[top];--top;printf("%c ",p->data); p=p->rchild;}}}/* 中序遍历的非递归实现 */void Inorder_recursive2(BTNode *bt){BTNode* p,*s[MAXNUM+1];int top;p=bt;top=-1;while(p||top !=-1){if(p && p->lchild){++top;s[top]= p;p = p->lchild;}else{if(p)printf("%c ", p->data);if(p && p->rchild ){p = p->rchild;}else if( top >= 0){p = s[top];top--;printf("%c ", p->data); p = p->rchild;}elsebreak;}}}二叉树的后序遍历,递归、非递归的实现:/* 后序遍历的递归实现 */void Postorder(BTNode *bt){if(bt){Postorder(bt->lchild);Postorder(bt->rchild);printf("%c ",bt->data);}}/* 后序遍历的非递归实现 */void Postorder_recursive(BTNode *pt) {BTNode *s[MAXNUM+1];int top =-1;BTNode *p = pt;BTNode *pre =NULL;while( p || top !=-1 ){if(p ){++top;s[top]= p;p = p->lchild;pre = p;}else{p = s[top];// --top;if( p->rchild ==NULL|| p->rchild == pre ){p = s[top];--top;printf("%c ", p->data);pre =p;p =NULL;}else{p = p->rchild;pre = p;}}}}层次遍历:{BTNode*queue[100];int front=0,rear=0;if(bt==NULL)return;queue[rear]=bt;rear++;do{printf("%c ",queue[front]->data);/*访问队首结点的数据域*/if(queue[front]->lchild!=NULL)/*将队首结点的左孩子结点入队列*/{queue[rear]=queue[front]->lchild; rear++;}if(queue[front]->rchild!=NULL)/*将队首结点的右孩子结点入队列*/{queue[rear]=queue[front]->rchild; rear++;}front++;。
二叉树的先序遍历、中序遍历、后续遍历(采用递归和栈两种)层序遍历(使用队列)
⼆叉树的先序遍历、中序遍历、后续遍历(采⽤递归和栈两种)层序遍历(使⽤队列)⾸先我们要先⾃⼰建⽴⼀个⼆叉树,我们先根据我⾃⼰随便写的⼆叉树建⽴⼀个列表保存⼆叉树的各个节点的信息,当然你也可以直接写个程序⾃⼰建⽴。
node_list = [{'data':'A', 'left':'B', 'right':'C', 'is_root':True},{'data':'B', 'left':'D', 'right':'E', 'is_root':False},{'data':'C', 'left':'F', 'right':'G', 'is_root':False},{'data':'D', 'left':None, 'right':None, 'is_root':False},{'data':'E', 'left':'H', 'right':None, 'is_root':False},{'data':'H', 'left':None, 'right':None, 'is_root':False},{'data':'F', 'left':None, 'right':None, 'is_root':False},{'data':'G', 'left':'I', 'right':'J', 'is_root':False},{'data':'I', 'left':None, 'right':None, 'is_root':False},{'data':'J', 'left':None, 'right':None, 'is_root':False}]然后根据建的列表建⽴⼀个⼆叉树1from collections import deque2class BinTreeNode(object):3def__init__(self, data, left=None, right=None):4 self.data, self.left, self.right = data, left, right56class BinTree(object):78def__init__(self, root=None):9 self.root = root1011 @classmethod12def build_form(cls, node_list):13 node_dict = {}14for node_data in node_list:15#这⼀步是把所有节点存在node_dict中16 data = node_data['data']17 node_dict[data] = BinTreeNode(data)18'''这⼀步是根据存在node_dict中的节点字典,把对应的左右节点对应上'''19for node_data in node_list:20 data = node_data['data']21if node_data['is_root']:22 root = node_dict[data]23 node_dict[data].left = node_dict.get(node_data['left'])24 node_dict[data].right = node_dict.get(node_data['right'])25return cls(root)接下来是⼏种遍历先序遍历:即先遍历根节点然后遍历左节点接着是右节点第⼀种:采⽤递归['A', 'B', 'D', 'E', 'H', 'C', 'F', 'G', 'I', 'J']def prevorder_trav(self, subtree):if subtree:yield subtreeyield from self.prevorder_trav(subtree.left)yield from self.prevorder_trav(subtree.right)我个⼈⽐较倾向于返回对应节点⽽不是直接返回值,这样我们还可以对⼆叉树的每个节点操作。
c语言二叉树的递归的遍历
c语言二叉树的递归的遍历在C语言中,二叉树的递归遍历可以通过三种方式实现,分别是前序遍历、中序遍历和后序遍历。
下面分别给出这三种遍历的递归实现代码。
1. 前序遍历(根-左-右):```#include <stdio.h>#include <stdlib.h>struct TreeNode {int val;struct TreeNode* left;struct TreeNode* right;};void preorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->val); // 先处理根节点preorderTraversal(root->left); // 递归处理左子树preorderTraversal(root->right); // 递归处理右子树}2. 中序遍历(左-根-右):```#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); // 递归处理右子树}```3. 后序遍历(左-右-根):#include <stdio.h>#include <stdlib.h>struct TreeNode {int val;struct TreeNode* left;struct TreeNode* right;};void postorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}postorderTraversal(root->left); // 递归处理左子树postorderTraversal(root->right); // 递归处理右子树printf("%d ", root->val); // 处理根节点}```以上代码中,结构体`TreeNode`表示二叉树的节点,包含一个`val`字段表示节点的值,以及`left`和`right`字段分别指向左子树和右子树的节点。
二叉树c语言实现完整代码
二叉树c语言实现完整代码二叉树是一种非常常见的数据结构,它由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在计算机科学中,二叉树被广泛应用于搜索、排序、编译器等领域。
本文将介绍如何使用C语言实现二叉树的完整代码。
我们需要定义二叉树的节点结构体。
每个节点包含三个成员变量:数据、左子节点和右子节点。
代码如下:```struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};```接下来,我们需要实现二叉树的基本操作,包括创建节点、插入节点、删除节点、查找节点等。
这些操作可以通过递归实现。
代码如下:```// 创建节点struct TreeNode* createNode(int val) {struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));node->val = val;node->left = NULL;node->right = NULL;return node;}// 插入节点struct TreeNode* insertNode(struct TreeNode* root, int val) {if (root == NULL) {return createNode(val);}if (val < root->val) {root->left = insertNode(root->left, val);} else {root->right = insertNode(root->right, val);}return root;}// 删除节点struct TreeNode* deleteNode(struct TreeNode* root, int val) {if (root == NULL) {return NULL;}if (val < root->val) {root->left = deleteNode(root->left, val);} else if (val > root->val) {root->right = deleteNode(root->right, val);} else {if (root->left == NULL) {struct TreeNode* temp = root->right;free(root);return temp;} else if (root->right == NULL) {struct TreeNode* temp = root->left;free(root);return temp;}struct TreeNode* temp = findMin(root->right); root->val = temp->val;root->right = deleteNode(root->right, temp->val); }return root;}// 查找节点struct TreeNode* searchNode(struct TreeNode* root, int val) {if (root == NULL || root->val == val) {return root;}if (val < root->val) {return searchNode(root->left, val);} else {return searchNode(root->right, val);}}// 查找最小节点struct TreeNode* findMin(struct TreeNode* root) {while (root->left != NULL) {root = root->left;}return root;}```我们需要实现二叉树的遍历操作,包括前序遍历、中序遍历和后序遍历。
C++二叉树的前序,中序,后序,层序遍历的递归算法
q->data[q->rear]=t;q->count++;q->rear=(q->rear+1)%queuesize;//将根节点入队
while(q->count)
if(q->data[q->front])
PostOrder(ss);
cout<<endl<<"层次遍历二叉树:";
leverorder(ss);
cout<<endl;
return 0;
}
int main()
{
shuru();
BiTree ss;
int i=CreatBiTree(ss);
cout<<endl<<"先序遍历二叉树:";
PreOrder(ss);
cout<<endl<<"中序遍历二叉树:";
InOrder(ss);
cout<<endl<<"后序遍历二叉树:";
if(NULL==p)
return ERROR;
jj++;
p->data=ch;
p->lchild=p->rchild=NULL;
}
rear++;
q[rear]=p;
if(1==rear)
root=p;
else
{
二叉树前序、中序、后序遍历相互求法
二叉树前序、中序、后序遍历相互求法今天来总结下二叉树前序、中序、后序遍历相互求法,即如果知道两个的遍历,如何求第三种遍历方法,比较笨的方法是画出来二叉树,然后根据各种遍历不同的特性来求,也可以编程求出,下面我们分别说明。
首先,我们看看前序、中序、后序遍历的特性:前序遍历:1.访问根节点2.前序遍历左子树3.前序遍历右子树中序遍历:1.中序遍历左子树2.访问根节点3.中序遍历右子树后序遍历:1.后序遍历左子树2.后序遍历右子树3.访问根节点一、已知前序、中序遍历,求后序遍历例:前序遍历: GDAFEMHZ中序遍历: ADEFGHMZ画树求法:第一步,根据前序遍历的特点,我们知道根结点为G第二步,观察中序遍历ADEFGHMZ。
其中root节点G左侧的ADEF必然是root的左子树,G右侧的HMZ必然是root的右子树。
第三步,观察左子树ADEF,左子树的中的根节点必然是大树的root的leftchild。
在前序遍历中,大树的root的leftchild位于root之后,所以左子树的根节点为D。
第四步,同样的道理,root的右子树节点HMZ中的根节点也可以通过前序遍历求得。
在前序遍历中,一定是先把root和root的所有左子树节点遍历完之后才会遍历右子树,并且遍历的左子树的第一个节点就是左子树的根节点。
同理,遍历的右子树的第一个节点就是右子树的根节点。
第五步,观察发现,上面的过程是递归的。
先找到当前树的根节点,然后划分为左子树,右子树,然后进入左子树重复上面的过程,然后进入右子树重复上面的过程。
最后就可以还原一棵树了。
该步递归的过程可以简洁表达如下:1 确定根,确定左子树,确定右子树。
2 在左子树中递归。
3 在右子树中递归。
4 打印当前根。
那么,我们可以画出这个二叉树的形状:那么,根据后序的遍历规则,我们可以知道,后序遍历顺序为:AEFDHZMG编程求法:(依据上面的思路,写递归程序)1 #include <iostream>2 #include <fstream>3 #include <string>45 struct TreeNode6 {7 struct TreeNode* left;8 struct TreeNode* right;9 char elem;10 };1112 void BinaryTreeFromOrderings(char* inorder, char* preorder, int length)13 {14 if(length == 0)15 {16 //cout<<"invalid length";17 return;18 }19 TreeNode* node = new TreeNode;//Noice that [new] should be written out.20 node->elem = *preorder;21 int rootIndex = 0;22 for(;rootIndex < length; rootIndex++)23 {24 if(inorder[rootIndex] == *preorder)25 break;26 }27 //Left28 BinaryTreeFromOrderings(inorder, preorder +1, rootIndex);29 //Right30 BinaryTreeFromOrderings(inorder + rootIndex + 1, preorder + rootIndex + 1, length - (rootIndex + 1));31 cout<<node->elem<<endl;32 return;33 }343536 int main(int argc, char* argv[])37 {38 printf("Hello World!\n");39 char* pr="GDAFEMHZ";40 char* in="ADEFGHMZ";4142 BinaryTreeFromOrderings(in, pr, 8);4344 printf("\n");45 return 0;46 }输出的结果为:AEFDHZMG二、已知中序和后序遍历,求前序遍历依然是上面的题,这次我们只给出中序和后序遍历:中序遍历: ADEFGHMZ后序遍历: AEFDHZMG画树求法:第一步,根据后序遍历的特点,我们知道后序遍历最后一个结点即为根结点,即根结点为G。
二叉树遍历c语言程序
二叉树遍历c语言程序二叉树遍历是指按照一定的顺序访问二叉树中的所有节点,将节点的值输出或进行其他操作。
在计算机科学中,二叉树遍历是一项基本的算法操作,常被用于解决各种问题,比如搜索、排序等。
本文将介绍二叉树遍历的概念和常见的遍历算法,并给出C语言实现的示例程序。
一、二叉树遍历的概念二叉树是由节点组成的树状数据结构,每个节点最多有两个子节点。
在二叉树中,每个节点都有一个值和指向其左右子节点的指针。
二叉树的遍历即按照一定的顺序访问二叉树中的所有节点。
二、二叉树的遍历方式常见的二叉树遍历方式有三种:前序遍历、中序遍历和后序遍历。
下面分别介绍这三种遍历方式的特点及其对应的算法。
1. 前序遍历前序遍历的遍历顺序是先访问根节点,然后依次递归遍历左子树和右子树。
具体算法如下:- 访问根节点;- 递归遍历左子树;- 递归遍历右子树。
2. 中序遍历中序遍历的遍历顺序是先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
具体算法如下:- 递归遍历左子树;- 访问根节点;- 递归遍历右子树。
3. 后序遍历后序遍历的遍历顺序是先递归遍历左子树,然后递归遍历右子树,最后访问根节点。
具体算法如下:- 递归遍历左子树;- 递归遍历右子树;- 访问根节点。
三、C语言实现二叉树遍历的示例程序下面给出C语言实现二叉树遍历的示例程序。
首先定义二叉树的节点结构体如下:```ctypedef struct TreeNode {int val;struct TreeNode* left;struct TreeNode* right;} TreeNode;```1. 前序遍历的C语言实现```cvoid preorderTraversal(TreeNode* root) { if (root == NULL) {return;}printf("%d ", root->val);preorderTraversal(root->left);preorderTraversal(root->right);}```2. 中序遍历的C语言实现```cvoid inorderTraversal(TreeNode* root) { if (root == NULL) {return;}inorderTraversal(root->left);printf("%d ", root->val);inorderTraversal(root->right);}```3. 后序遍历的C语言实现```cvoid postorderTraversal(TreeNode* root) {if (root == NULL) {return;}postorderTraversal(root->left);postorderTraversal(root->right);printf("%d ", root->val);}```四、总结二叉树遍历是一项基本的算法操作,在解决各种问题时经常会用到。
C语言递归实现二叉树的先序、中序、后序遍历
C语⾔递归实现⼆叉树的先序、中序、后序遍历#include <stdio.h>#include <stdlib.h>//*****⼆叉树的⼆叉链表存储表⽰*****//typedef struct BiNode{char data;struct BiNode *lchild, *rchild;}BiNode, *BiTree;//*****按先序次序输⼊⼆叉树中结点的值(⼀个字符),空格字符表⽰空树构造⼆叉链表表⽰的⼆叉树T*****//void CreateBiTree(BiTree &T){char ch;scanf("%c", &ch);if(ch == ' '){T = NULL;}else{if(!(T = (BiNode *)malloc(sizeof(BiNode)))){return;}T->data = ch; //⽣成根结点CreateBiTree(T->lchild); //构造左⼦树CreateBiTree(T->rchild); //构造右⼦树}return;}//*****先序遍历⼆叉树*****//void PreOrderTraverse(BiTree T){if(!T){return; //若T为空树,则直接返回}printf("%c ", T->data); //訪问根结点PreOrderTraverse(T->lchild); //先序遍历左⼦树PreOrderTraverse(T->rchild); //先序遍历右⼦树return;}//*****中序遍历⼆叉树*****//void InOrderTraverse(BiTree T){if(!T){return; //若T为空树,则直接返回}InOrderTraverse(T->lchild); //中序遍历左⼦树printf("%c ", T->data); //訪问根结点InOrderTraverse(T->rchild); //中序遍历右⼦树return;}//*****后序遍历⼆叉树*****//void PostOrderTraverse(BiTree T){if(!T){return; //若T为空树,则直接返回}PostOrderTraverse(T->lchild); //后序遍历左⼦树PostOrderTraverse(T->rchild); //后序遍历右⼦树printf("%c ", T->data); //訪问根结点return;}int main(void){BiTree T;printf("请按先序次序输⼊⼆叉树中结点的值(字符),空格字符表⽰空树:\n");CreateBiTree(T);printf("先序遍历结果为:");PreOrderTraverse(T);printf("\n\n");printf("中序遍历结果为:");InOrderTraverse(T);printf("\n\n");printf("后序遍历结果为:");PostOrderTraverse(T);printf("\n\n");return 0;}以例如以下⼆叉树为例,给出按先序次序输⼊⼆叉树中结点的值(字符),从⽽依照本⽂给出的算法构造⼆叉树。
二叉树的先序,中序,后序遍历非递归c语言
二叉树的先序,中序,后序遍历非递归c语言二叉树是一种常见的数据结构,它的每个节点最多只能有两个子节点。
遍历二叉树是指按照一定的顺序访问二叉树中的所有节点,常见的遍历方式有先序遍历、中序遍历和后序遍历。
在二叉树的遍历过程中,递归是一种常见的解决方法。
但是递归实现有一些缺点,比如需要使用函数调用栈,对于大型二叉树可能导致栈溢出。
为了解决这个问题,我们可以使用非递归的方式来实现二叉树的遍历。
在C语言中,二叉树通常使用指针来表示。
每个节点包含一个数据元素和指向左右子节点的指针。
我们可以使用栈来模拟递归的过程,将需要访问的节点入栈,并在访问完节点后将其出栈,以此来实现非递归的遍历。
首先,我们来看一下二叉树的结构定义:```struct TreeNode {int val; //节点的值struct TreeNode* left; //左子节点struct TreeNode* right; //右子节点};```根据这个定义,我们可以实现先序、中序和后序遍历。
下面分别给出这三种遍历的实现过程:1.先序遍历:先序遍历的顺序是根节点、左子树、右子树。
我们可以使用一个栈来模拟递归的过程,具体步骤如下:-首先,创建一个空栈和一个指向根节点的指针cur。
-将cur指针指向的节点入栈,并将其值打印出来。
-如果栈不为空,将栈顶节点出栈,将cur指针指向出栈节点的右子节点。
-如果cur指针不为空,则将cur指针指向的节点入栈,并将其值打印出来。
-如果cur指针为空且栈不为空,将栈顶节点出栈,将cur指针指向出栈节点的右子节点。
-重复上述步骤,直到cur指针为空且栈为空。
下面是先序遍历的非递归实现代码:```cvoid preOrderTraversal(struct TreeNode* root) {if (root == NULL) {return;}//创建一个栈struct TreeNode* stack[STACK_SIZE];int top = -1;struct TreeNode* cur = root;while (cur != NULL || top != -1) { while (cur != NULL) {printf("%d ", cur->val);stack[++top] = cur;cur = cur->left;}if (top != -1) {cur = stack[top--];cur = cur->right;}}}```2.中序遍历:中序遍历的顺序是左子树、根节点、右子树。
C++数据结构二叉树(前序中序后序递归、非递归遍历)
C++数据结构⼆叉树(前序中序后序递归、⾮递归遍历)C++ 数据结构⼆叉树(前序/中序/后序递归、⾮递归遍历)⼆叉树的性质:⼆叉树是⼀棵特殊的树,⼆叉树每个节点最多有两个孩⼦结点,分别称为左孩⼦和右孩⼦。
例:实例代码:#include <iostream>#include <Windows.h>#include <stack>using namespace std;template <class T>struct BinaryTreeNode{int _data;BinaryTreeNode<T>* _left; //左孩⼦BinaryTreeNode<T>* _right; //右孩⼦BinaryTreeNode(const T& data):_data(data), _left(NULL), _right(NULL){}};template <class T>class BinaryTree{typedef BinaryTreeNode<T> Node;public:BinaryTree():_root(NULL){}BinaryTree(T* arr, size_t n, const T& invalid=T()){size_t index = 0;_root = _CreatTree(arr, n, invalid, index);}void PreOrderR() //前序遍历递归{_PreOrderR(_root);}void PreOrder() //前序遍历⾮递归{_PreOrder(_root);}void InOrderR() //中序遍历递归{_InOrderR(_root);}void InOrder() //中序遍历⾮递归{_InOrder(_root);}void PostOrderR() //后序遍历左右根递归{_PostOrderR(_root);}void PostOrder() //后序遍历左右根⾮递归{_PostOrder(_root);}~BinaryTree(){}protected://建树 arr:建树使⽤的数组 n:数组⼤⼩ invalid:⾮法值 index:当前下标 Node* _CreatTree(T* arr, size_t n, const T& invalid, size_t& index) {Node* root = NULL;if (index < n && arr[index] != invalid){root = new Node(arr[index]); //根节点root->_left = _CreatTree(arr, n, invalid, ++index);root->_right = _CreatTree(arr, n, invalid, ++index);}return root;}void _PreOrderR(Node* root) //前序遍历递归{if (root == NULL){return;}cout << root->_data << " ";_PreOrderR(root->_left);_PreOrderR(root->_right);}void _PreOrder(Node* root) //前序遍历⾮递归{stack<Node*> tty;while (root != NULL || !tty.empty()){if (root){cout << root->_data << " ";tty.push(root);root = root->_left;}else{Node* temp = tty.top();tty.pop();root = temp->_right;}}}void _InOrderR(Node* root) //中序遍历递归{if (root == NULL){return;}_InOrderR(root->_left);cout << root->_data << " ";_InOrderR(root->_right);}void _InOrder(Node* root) //中序遍历⾮递归{if (root == NULL){return;}stack<Node*> tty;while (root != NULL || !tty.empty()){while (root){tty.push(root);root = root->_left;}//此时出了循环⾛到了最左叶⼦节点Node* temp = tty.top();tty.pop();cout << temp->_data << " ";root = temp->_right;}}void _PostOrderR(Node* root) //后序遍历左右根递归{if (root == NULL){return;}_PostOrderR(root->_left);_PostOrderR(root->_right);cout << root->_data << " ";}void _PostOrder(Node* root) //后序遍历左右根⾮递归{if (root == NULL){return;}stack<Node*> tty;Node* PreNode = NULL; //上⼀个访问的结点tty.push(root);while (!tty.empty()){Node* cur = tty.top();//访问的当前节点左右孩⼦均为空或者当前节点左右⼦树均已经访问过if ((cur->_left == NULL && cur->_right == NULL) || ((PreNode != NULL) && (PreNode == cur->_left || PreNode == cur->_right))) {cout << cur->_data << " ";tty.pop();PreNode = cur;}else{if (cur->_right != NULL){tty.push(cur->_right);}if (cur->_left != NULL){tty.push(cur->_left);}}}}protected:Node* _root;};#include "源.h"void Test(){int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };BinaryTree<int> p(array, sizeof(array) / sizeof(array[0]), '#');cout << "前序递归遍历: " << "";p.PreOrderR();cout << endl;cout << "前序⾮递归遍历: " << "";p.PreOrder();cout << endl;cout << "中序递归遍历: " << "";p.InOrderR();cout << endl;cout << "中序⾮递归遍历: " << "";p.InOrder();cout << endl;cout << "后序递归遍历: " << "";p.PostOrderR();cout << endl;cout << "后序⾮递归遍历: " << "";p.PostOrder();cout << endl;}int main(){Test();system("pause");return 0;}实现效果:以上就是数据结构⼆叉树的详解,如有疑问请留⾔或者到本站社区交流讨论,感谢阅读,希望能帮助到⼤家,谢谢⼤家对本站的⽀持!。
C二叉树创建前序遍历中序遍历后序遍历的递归与非递归实现以及层次遍历
C二叉树创建前序遍历中序遍历后序遍历的递归与非递归实现以及层次遍历二叉树是一种常用的数据结构,在进行树的相关操作时,经常会遇到三种遍历方式:前序遍历、中序遍历和后序遍历。
同时,层次遍历也是一种重要的遍历方式。
下面将分别介绍二叉树的前序遍历、中序遍历和后序遍历的递归和非递归实现,以及层次遍历的算法。
1.前序遍历:前序遍历的顺序是先访问根节点,然后遍历左子树,最后遍历右子树。
递归实现:在递归实现中,先输出当前节点的值,然后递归调用遍历左子树和右子树。
非递归实现:非递归实现使用栈,首先将根节点入栈。
然后循环执行以下步骤:弹出栈顶节点并输出,依次将右子节点和左子节点入栈,直到栈为空。
2.中序遍历:中序遍历的顺序是先遍历左子树,然后访问根节点,最后遍历右子树。
递归实现:在递归实现中,先递归调用遍历左子树,然后输出当前节点的值,最后递归调用遍历右子树。
非递归实现:非递归实现使用栈,先将根节点入栈。
然后循环执行以下步骤:将当前节点的所有左子节点依次入栈,直到没有左子节点。
然后弹出栈顶节点并输出,将当前节点的右子节点入栈。
3.后序遍历:后序遍历的顺序是先遍历左子树,然后遍历右子树,最后访问根节点。
递归实现:在递归实现中,先递归调用遍历左子树,然后递归调用遍历右子树,最后输出当前节点的值。
非递归实现:非递归实现使用栈,首先将根节点入栈。
使用一个辅助栈,循环执行以下步骤:弹出栈顶节点并压入辅助栈。
依次将左子节点和右子节点入栈,直到栈为空。
最后从辅助栈依次弹出节点并输出。
4.层次遍历:层次遍历的顺序是从上到下一层一层遍历,同一层节点从左到右遍历。
算法:使用队列实现层次遍历的算法。
首先将根节点入队。
然后循环执行以下步骤:弹出队列头节点并输出,将弹出节点的左子节点和右子节点入队,直到队列为空。
以上便是二叉树的前序遍历、中序遍历和后序遍历的递归和非递归实现,以及层次遍历的算法。
其中递归实现简洁明了,但在处理大规模数据时可能会导致栈溢出。
c语言实现二叉树各种基本运算的算法
c语言实现二叉树各种基本运算的算法二叉树是一种常见的数据结构,可以应用于许多算法和问题中。
在C语言中,我们可以使用指针和结构体来实现二叉树的各种基本运算。
本文将详细介绍二叉树的创建、插入、删除、查找以及遍历等基本操作的算法。
1.创建二叉树创建二叉树可以通过递归的方式来实现。
首先定义一个表示二叉树节点的结构体,包含一个值和左右子节点指针。
然后,通过递归地创建左右子树来构建整个二叉树。
```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;//创建二叉树TreeNode* createBinaryTree() {int data;scanf("%d", &data);if (data == -1) { // -1表示空节点return NULL;}TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->data = data;node->left = createBinaryTree();node->right = createBinaryTree();return node;}```2.插入节点在二叉树中插入节点可以按照二叉搜索树的性质进行。
如果要插入的值小于当前节点的值,则将其插入到左子树中,否则插入到右子树中。
如果子树为空,则直接创建一个新节点作为子树。
```c//插入节点TreeNode* insertNode(TreeNode* root, int data) {if (root == NULL) {TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}if (data < root->data) {root->left = insertNode(root->left, data);} else {root->right = insertNode(root->right, data);}return root;}```3.删除节点删除二叉树中的节点可以分为三种情况:删除叶子节点、删除只有一个子节点的节点、删除有两个子节点的节点。
二叉树前序遍历、中序遍历和后序遍历及C语言非递归实现
⼆叉树前序遍历、中序遍历和后序遍历及C语⾔⾮递归实现递归算法底层的实现使⽤的是栈存储结构,所以可以直接使⽤栈写出相应的⾮递归算法。
先序遍历的⾮递归算法从树的根结点出发,遍历左孩⼦的同时,先将每个结点的右孩⼦压栈。
当遇到结点没有左孩⼦的时候,取栈顶的右孩⼦。
重复以上过程。
实现代码函数://先序遍历⾮递归算法void PreOrderTraverse(BiTree Tree){BiTNode* a[20];//定义⼀个顺序栈BiTNode * p;//临时指针push(a, Tree);//根结点进栈while (top!=-1) {p=getTop(a);//取栈顶元素pop();//弹栈while (p) {displayElem(p);//调⽤结点的操作函数//如果该结点有右孩⼦,右孩⼦进栈if (p->rchild) {push(a,p->rchild);}p=p->lchild;//⼀直指向根结点最后⼀个左孩⼦}}}中序遍历的⾮递归算法从根结点开始,遍历左孩⼦同时压栈,当遍历结束,说明当前遍历的结点没有左孩⼦,从栈中取出来调⽤操作函数,然后访问该结点的右孩⼦,继续以上重复性的操作。
实现代码函数://中序遍历⾮递归算法void InOrderTraverse1(BiTree Tree){BiTNode* a[20];//定义⼀个顺序栈BiTNode * p;//临时指针push(a, Tree);//根结点进栈while (top!=-1) {//top!=-1说明栈内不为空,程序继续运⾏while ((p=getTop(a)) &&p){//取栈顶元素,且不能为NULLpush(a, p->lchild);//将该结点的左孩⼦进栈,如果没有左孩⼦,NULL进栈}pop();//跳出循环,栈顶元素肯定为NULL,将NULL弹栈if (top!=-1) {p=getTop(a);//取栈顶元素pop();//栈顶元素弹栈displayElem(p);push(a, p->rchild);//将p指向的结点的右孩⼦进栈}}}补:中序遍历⾮递归算法的另⼀种实现中序遍历过程中,只需将每个结点的左⼦树压栈即可,右⼦树不需要压栈。
已知二叉树的中序遍历和后序遍历,求先序遍历c语言
已知二叉树的中序遍历和后序遍历,求先序遍历c语言 */#include <stdio.h>#include <stdlib.h>struct TreeNode{tint data;tstruct TreeNode* left;tstruct TreeNode* right;};// 获取两个序列中的某个节点的位置int GetIndex(int* arr, int len, int data){tint index = -1;tfor (int i = 0; i<len; i++)t{ttif (arr[i] == data)tt{tttindex = i;tttbreak;tt}t}treturn index;}// 通过中序遍历和后序遍历来构建树struct TreeNode* GetTree(int* inorder, int* postorder, int len){t// 根节点位于后序遍历的最后tint root_data = postorder[len - 1];t// 在中序遍历中找到根节点的位置tint root_index = GetIndex(inorder, len, root_data);t// 找不到该节点,数据错误tif (root_index == -1)ttreturn NULL;t// 创建根节点tstruct TreeNode* root = (structTreeNode*)malloc(sizeof(struct TreeNode));troot->data = root_data;troot->left = NULL;troot->right = NULL;t// 后序遍历的左子树结点个数tint left_len = root_index;t// 后序遍历的右子树结点个数tint right_len = len - left_len - 1;t// 构建左子树tif (left_len > 0)t{tt// 左子树的中序遍历和后序遍历ttint* left_inorder = inorder;ttint* left_postorder = postorder;tt// 递归构建左子树ttroot->left = GetTree(left_inorder, left_postorder, left_len);t}t// 构建右子树tif (right_len > 0)t{tt// 右子树的中序遍历和后序遍历ttint* right_inorder = inorder + root_index + 1;ttint* right_postorder = postorder + root_index;tt// 递归构建右子树ttroot->right = GetTree(right_inorder, right_postorder, right_len);t}treturn root;}// 先序遍历void PreOrder(struct TreeNode* root){tif (root != NULL)t{tt// 先遍历根节点ttprintf('%d ', root->data);tt// 再遍历左子树ttPreOrder(root->left);tt// 最后遍历右子树ttPreOrder(root->right);t}}int main(){t// 中序遍历tint inorder[] = { 2, 4, 5, 7, 8, 9, 10 };t// 后序遍历tint postorder[] = { 4, 5, 2, 9, 10, 8, 7 };tint len = sizeof(inorder) / sizeof(inorder[0]); t// 构建树tstruct TreeNode* root = GetTree(inorder, postorder, len); t// 先序遍历tPreOrder(root);tprintf('');treturn 0;}。
C语言实现二叉树的前序、中序、后续遍历(递归法)
二叉树的前序遍历、中序遍历、后续遍历(递归法)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);}供测试使用的数据。
C语言二叉树的三种遍历方式的实现及原理
C语⾔⼆叉树的三种遍历⽅式的实现及原理⼆叉树遍历分为三种:前序、中序、后序,其中序遍历最为重要。
为啥叫这个名字?是根据根节点的顺序命名的。
⽐如上图正常的⼀个满节点,A:根节点、B:左节点、C:右节点,前序顺序是ABC(根节点排最先,然后同级先左后右);中序顺序是BAC(先左后根最后右);后序顺序是BCA(先左后右最后根)。
⽐如上图⼆叉树遍历结果前序遍历:ABCDEFGHK中序遍历:BDCAEHGKF后序遍历:DCBHKGFEA分析中序遍历如下图,中序⽐较重要(java很多树排序是基于中序,后⾯讲解分析)下⾯介绍⼀下,⼆叉树的三种遍历⽅式,其中每⼀种遍历⽅式都有三种实现⽅式。
节点定义:struct TreeNode{int val;TreeNode *left,*right;TreeNode(int val){this->val = val;this ->left = this->right = NULL;}};先序遍历以上⾯这张图为例:我们讲讲树的三种遍历⽅式:先序遍历:先访问根节点,然后访问左孩⼦,最后访问右孩⼦。
所以,上⾯遍历的结果是:GEDACHS。
下⾯,我们来看看具体代码实现1.递归实现void preOrder(TreeNode *root){if (root==NULL)return;cout<<root->val<<endl;preOrder(root->left);preOrder(root->right);}2.使⽤辅助栈 实现思路:1.将根节点⼊栈 2.每次从栈顶弹出⼀个节点,访问该节点 3.把当前节点的右孩⼦⼊栈 4.把当前节点的左孩⼦⼊栈 具体实现:void preOrder2(TreeNode *root){if (root == NULL)return;stack<TreeNode*> stk; //开辟⼀个栈空间stk.push(root);while(!stk.empty()){TreeNode* pNode = stk.pop();cout<<pNode->val;if (pNode->right!=NULL)stk.push(pNode->right);if (pNode->left!=NULL)stk.push(pNode->left);}}3.Morris遍历Morris遍历,常数的空间即可在O(n)时间内完成⼆叉树的遍历。
二叉树遍历C语言递归,非递归六种算法
数据结构〔双语〕——工程文档报告用两种方式实现表达式自动计算专业:班级:指导教师:姓名:学号:目录一、思想⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.01二、算法流程⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.02三、源代⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.04四、运行果⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.11五、遇到的及解决⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.11六、心得领悟⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯⋯.12一、设计思想二叉树的遍历分为三种方式,分别是先序遍历,中序遍历和后序遍历。
先序遍历实现的次序是:根左右,中序遍历实现的是:左根右,后续遍历实现的是:左右根。
依照不一样的算法分,又分为递归遍历和非递归遍历。
递归算法:1.先序遍历:先序遍历就是第一判断根结点可否为空,为空那么停止遍历,不为空那么将左子作为新的根结点重新进行上述判断,左子遍历结束后,再将右子作为根结点判断,直至结束。
到达每一个结点时,打印该结点数据,即得先序遍历结果。
2.中序遍历:中序遍历是第一判断该结点可否为空,为空那么结束,不为空那么将左子作为根结点再进行判断,打印左子,尔后打印二叉树的根结点,最后再将右子作为参数进行判断,打印右子,直至结束。
3.后续遍历:指针到达一个结点时,判断该结点可否为空,为空那么停止遍历,不为空那么将左子作为新的结点参数进行判断,打印左子。
左子判断完成后,将右子作为结点参数传入判断,打印右子。
左右子判断完成后打印根结点。
非递归算法:1.先序遍历:第一建立一个栈,当指针到达根结点时,打印根结点,判断根结点可否有左子和右子。
有左子和右子的话就打印左子同时将右子入栈,将左子作为新的根结点进行判断,方法同上。
假设当前结点没有左子,那么直接将右子打印,同时将右子作为新的根结点判断。
假设当前结点没有右子,那么打印左子,同时将左子作为新的根结点判断。
假设当前结点既没有左子也没有右子,那么当前结点为叶子结点,此时将从栈中出栈一个元素,作为当前的根结点,打印结点元素,同时将当前结点同样按上述方法判断,依次进行。
二叉树前序中序后序遍历算法
二叉树前序中序后序遍历算法二叉树的遍历是指按照一定顺序访问二叉树中所有节点的过程。
常用的遍历方式有前序遍历、中序遍历和后序遍历。
下面将详细介绍这三种遍历算法。
一、前序遍历前序遍历的算法是先访问根节点,然后递归地前序遍历根节点的左子树,最后递归地前序遍历根节点的右子树。
具体步骤如下:1.如果树为空,则返回。
2.访问根节点。
3.递归地前序遍历根节点的左子树。
4.递归地前序遍历根节点的右子树。
实现前序遍历的算法可以使用递归或者栈来实现。
下面是一个使用递归实现前序遍历的示例代码:```pythondef pre_order_traversal(root):if root is None:returnprint(root.value) # 访问根节点pre_order_traversal(root.left) # 递归前序遍历左子树pre_order_traversal(root.right) # 递归前序遍历右子树```二、中序遍历中序遍历的算法是先递归地中序遍历根节点的左子树,然后访问根节点,最后递归地中序遍历根节点的右子树。
具体步骤如下:1.如果树为空,则返回。
2.递归地中序遍历根节点的左子树。
3.访问根节点。
4.递归地中序遍历根节点的右子树。
实现中序遍历的算法也可以使用递归或者栈来实现。
下面是一个使用递归实现中序遍历的示例代码:```pythondef in_order_traversal(root):if root is None:returnin_order_traversal(root.left) # 递归中序遍历左子树print(root.value) # 访问根节点in_order_traversal(root.right) # 递归中序遍历右子树```三、后序遍历后序遍历的算法是先递归地后序遍历根节点的左子树和右子树,最后访问根节点。
具体步骤如下:1.如果树为空,则返回。
2.递归地后序遍历根节点的左子树。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二叉树的前序遍历、中序遍历、后续遍历
(递归法)
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);
}
else
printf(" ");
}
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);
}
else
printf(" ");
}
void main()//主函数
{/*检测:printf("到了吗");*/
struct BiTNode *p;
later(p);
print(p);
}
供测试使用的数据。