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);}```四、总结二叉树遍历是一项基本的算法操作,在解决各种问题时经常会用到。
- 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);
}
供测试使用的数据。