二叉树

最新推荐文章于 2020-08-24 19:10:22 发布
最新推荐文章于 2020-08-24 19:10:22 发布
阅读量147 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41218103/article/details/107977458
版权

1.递归进行二叉树的建立、遍历：

//#include<iostream>
//using namespace std;
#include<stdio.h>
#include<stdlib.h>
#define maxsize 100
typedef  char datatype;
typedef struct BNode
{
	datatype data;
	struct BNode *lchild;
	struct BNode *rchild;
}BNode;
int i=0;
void init(BNode *&b)
{
   char ch;
  // printf("请输入:\n"); 
   /* 
   {
   ch=scanf("%c",&ch);
   getchar();
   用C语言scanf进行递归建立二叉树时总是无法跳出循环 ,因为在用scanf输入时ch未接收到赋给它的值 且为防止输入回车应在scanf后加上getcharts();
   }
   */
   ch= getchar();
   //用getchar()输入字符ch可以获取到赋给它的值且回车不会被赋给ch  
  // getchar(); 
  // cin>>ch;  
   printf("ch:%c\n",ch); 
   if(ch=='#')
   		b=NULL;
	else
	{
		b=(BNode *)malloc(sizeof(BNode));
	//	b=new BNode;
		b->data=ch;
		init(b->lchild);
		init(b->rchild);
	}
}
void print_f(BNode *b)  //递归法进行先序遍历 
{
	if(b!=NULL)  
	//注意要进行判断b是否为空,因为二叉树中有节点为NULL,若不进行判断则会直接进行NULL节点的值的输出从而导致错误
	{
	printf("%c",b->data);
	printf("(");
	print_f(b->lchild);
	printf(",");
	print_f(b->rchild);
	printf(")");
	}
}
int main()
{
    BNode *b;
	init(b);
	printf("ok!\n");
	print_f(b);
	return 0;
}

2.非递归进行二叉树的建立与遍历：

后序:

void postorder(BNode *b)
 {
 	BNode *str[maxsize],*p=b;//*str[maxsize]充当顺序栈
	int top=-1;
	do
	{
		while(p!=NULL)
		{
			top++;
			str[top]=p;
			p=p->lchild;
		}
		BNode *r=NULL;
		bool flag=true;  
		while(!(top==-1)&&flag)
		{
			p=str[top];
			if(p->rchild==r)  
			//栈顶元素的右子树指针是刚刚处理过的元素/为NULL => 栈顶结点的右子树已被处理过 
			{
				printf("%c",p->data);
				top--;
				r=p;// 令r指向刚刚处理的元素 
			}
			else
			{
				p=p->rchild; 
				flag=false;  //若栈顶元素的右子树未被处理过则 flag==false 
			}
		}
	 } while(!(top==-1));
 }

#include<stdio.h>
#include<stdlib.h>
#define maxsize 100
typedef  char datatype;
typedef struct BNode
{
	datatype data;
	struct BNode *lchild;
	struct BNode *rchild;
}BNode;
void init(BNode *&b,char *str)   //非递归构建二叉链表 "A(B(D(,G)),C(E,F)"
{
	BNode *p,*st[maxsize];
	b=NULL;
	int j=0,k=0,top=-1;
	char ch=str[j];
	while(ch!='\0')
	{
		printf("ch:%c\n",ch);
		switch (ch)
		{
			case '(':
				{
					k=1;   //用来决定ch后面的字母是左子树还是右子树
					top++;
					st[top]=p;
					break;
				}
			case ')':
				{
					top--;
					break;
				}
			case ',':
				{
					k=2;
					break;
				}
			default:
				{
					p=(BNode *)malloc(sizeof(BNode));
					p->data=ch;
					p->lchild=p->rchild=NULL;
					if(b==NULL)
						b=p;
					else
					{
						if(k==1)
						{
							st[top]->lchild=p;
						}
						else
						{
							st[top]->rchild=p;
						}
					}
				}
		}
		j++;
		ch=str[j];
	}
 } 
 void destory(BNode *&b)
 {
 	if (b!=NULL)
 	{
 		destory(b->lchild);
 		destory(b->rchild);
 		free(b);
	 }
  } 
  void preorder(BNode *b)
  {
  	BNode *str[maxsize],*p;
  	int top=-1;
  	if(b!=NULL)
  	{
  		printf("%c",b->data);
  		top++;
  		str[top]=b;
  		p=b->lchild;
  		while(!(top==-1&p==NULL))
		  //top==-1&p==NULL是遍历完成的条件，缺一个就可能是遍历过程中而不是遍历结束
		  //eg:当遍历完根的左子树开始遍历根的右子树时：此时top==-1，栈为空，但p!=NULL 
  		{
  			while(p!=NULL)
  			{
  				if(top<maxsize)
  				{
					printf("%c",p->data);
					top++;
					str[top]=p;
				  }
  				else
  				{
  					printf("栈满！\n");
				  }
				p=p->lchild;
		  	}
		  	p=str[top];
		  	top--;
		  	{
			  	p=p->rchild;
			}
		}
	  }
  }
  void inorder(BNode *b)
 {
 	BNode *str[maxsize],*p=b;
 	int top=-1;
 	while(!(top==-1&&p==NULL))
 	{
 		while(p!=NULL)
 		{
 			top++;
 			str[top]=p;
 			p=p->lchild;
		 }
		 printf("%c",str[top]->data);
		 p=str[top]->rchild;
		 top--;
	 }
 }
int main()
{
	char *str="A(B(D(,G)),C(E,F)";
    BNode *b;
	init(b,str);
	printf("ok!\n");
//	print_f(b);
	preorder(b);//非递归的先序遍历
	inorder(b); 
	destory(b);
	return 0;
}

3.层次遍历：

void ALLpath(BNode *b)//层次遍历,利用队列进行 
 {
 	BNode *str[maxsize],*p;
 	int front=0,rear=0;
 	if(b!=NULL)
 	{
 		str[rear]=b;
 		rear=(rear+1)%maxsize;
	 }
	 else
	 	return;  
 	while(rear!=front)
 	{
 		p=str[front];
 		printf("%c",p->data);
 		front=(front+1)%maxsize;
 		if(p->lchild!=NULL)
		{
			str[rear]=p->lchild;
 			rear=(rear+1)%maxsize;
		 }
		 if(p->rchild!=NULL)
		{
			str[rear]=p->rchild;
 			rear=(rear+1)%maxsize;
		 }
	 }
  }

5.插入一个节点（利用递归）：

void insert(BNode *&b,char ch,char parent) //将ch插入，作为parent的左子树 
 {
 	BNode *p;
 	if(b->data==parent)
 	{
 		printf("b->data:%c",b->data);
 		if(b->lchild!=NULL)
		 {
		 	p=(BNode *)malloc(sizeof(BNode));
			p->data=ch;
			p->lchild=b->lchild;
			p->rchild=NULL;
			b->lchild=p;
		  }
		  else
		  {
		  	p=(BNode *)malloc(sizeof(BNode));
			p->data=ch;
			p->lchild=NULL;
			p->rchild=NULL;
			b->lchild=p;
		  }
		return;
	 }
	    printf("%d\n",i++);
	    if(b->lchild!=NULL)  
		 //注意要进行判断，必须在 b->lchild!=NULL条件下对b->lchild进行递归插入 
	 		insert(b->lchild,ch,parent); 
	 	if(b->rchild!=NULL)
			insert(b->rchild,ch,parent);
 }
 void preorder(BNode *b) //输出二叉树 
 {
 	if(b->lchild!=NULL||b->rchild!=NULL)
 	{
 		printf("(");
 		if(b->lchild!=NULL)   
 			preorder(b->lchild);
 		if(b->rchild!=NULL)
 		{
 			printf(",");
 			preorder(b->rchild);
		 }
		 printf(")");
	 }
 }
 int main()
{
    BNode *b;
	init(b);
	preorder(b);
	printf("\nOK!\n");
	char K='K',D='C';
	insert(b,K,D);
	preorder(b);
	destory(b);
	return 0;
}

6.查找一个固定值的结点；求树的深度

void find(BNode *b,char ch)   //查找结点
 {
 	if(b->data==ch)
 	{
 		printf("find!!\n");
 		printf("b->data:%c\n",b->data);
	 }
	 else
	 {
	 	if(b->lchild!=NULL)
	 		find(b->lchild,ch);
	 	if(b->rchild!=NULL)
	 		find(b->rchild,ch);
	 }
  } 
  int height(BNode *b)  //求子树的高度，利用递归 
  {
  	int max,l,r;
  	if (b==NULL)
  		return 0;
  	else
  	{
  		l=height(b->lchild);
  		r=height(b->rchild);
  		if(l>r)
  			max=l;
  		else
  			max=r;
  		return max+1;
	  }
   }

7.递归的应用：

  1. 找叶子结点
void Displea(BNode *b)
 {
 	if(b->lchild==NULL&&b->rchild==NULL)
 		printf("%c",b->data);
 	else
 	{
 		if(b->lchild!=NULL)
 			Displea(b->lchild);
 		if(b->rchild!=NULL)
 			Displea(b->rchild);
	 }
 }
  1. 找结点的层次
bool flag=false;
 void level(BNode *b,char ch,int h)
 {
 	if (b->data==ch)
 	{
 		flag=true;
 		printf("结点深度:%d",h);	
	 }
 	else
 	{
 		if(b->lchild!=NULL)
 			level(b->lchild,ch,h+1);
 		if(flag==false&&b->rchild!=NULL)
 			level(b->rchild,ch,h+1);
	 }
 }
立里∑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树中的中的 BiTNode 和*BiTree 是什么，typedef struct BiTNode{ TElemType data; struct BiTNode *lchild
xiaoninvhuang的博客
03-21 3万+
typedef struct BiTNode{     TElemType  data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; 第四行代码中的 BiTNode 和*BiTree 是什么 其实这里让你迷糊的点并不是结构体，而是typedef的使用，耐心的看。 typedef的定义：
数据结构之二叉树篇总结
qq49649174的博客
08-23 247
树结构是一种比线性结构（例如：线性表、栈、队列等）复杂的数据结构，但是树结构在计算机领域中有着广泛的应用。二叉树是一种最简单的树结构，下面分析以二叉树为研究对象。 结点的度、树的度：某个结点拥有子树的个数，我们称之为某结点的度；而在一棵树中的某结点有最多的子树，该结点的度我们称之为树的度。 结点的层数、树的深度（高度）、树的宽度：记根结点的层数为1，结点的层数通过从根结点开始计数得到；树中所有...
二叉树——基本操作
qq_35424507的博客
08-24 146
// A code block 二叉树的一些基本操作 1. 层序遍历 2. 先序遍历 3. 后序遍历 4. 中序遍历 5. 倒叙遍历 6. 求树高 7. 求叶子节点数 // An highlighted block #include<stdio.h> #include<stdlib.h> #include<iostream> #define MAXSIZE 60 #define datatype char struct Tree
C语言二叉树的基本操作
android_hasen博客
08-05 1691
#include #include #define STACK_MAX_SIZE 30 #define QUEUE_MAX_SIZE 30 #ifndef elemType typedef char elemType; #endif /************************************************************************/ /*
建立二叉树时使用scanf读取输入时出现的错误
ZM970307的博客
04-10 522
构建二叉树的函数代码如下，运行的时候发现第一次输入一个字符A，然后按回车，发现下次等待用户输入前打印了两条“please input the data”语句。因为输入A以后再调用这个函数，scanf直接在输入流里面读取了10（回车），所以这次没有让用户输入，所以需要用户输入的时候，发现已经打印了两条语句。 void createBiThrTree(BiThrTree *T) { prin...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
C语言中base operand of ‘-＞‘is not a pointer的错误
热门推荐
qq_41218103的博客
07-25 1万+
如果你使用的变量x是个结构体，应该用.访问其成员，如：x.num 如果你使用的变量x是个结构体指针，应该用->访问其成员，如：x->num 如果当前变量x是个结构体而你却使用了x->num的方式访问，就属会出现上面的报错。 "."一般情况下读作"的”，结构体a的b。 “->”一般读作"指向的结构体的"，a指向的结构体的b ...
一元多项式相加（单链表的应用）
qq_41218103的博客
08-02 1086
#include<stdio.h> #include<stdlib.h> typedef struct Lnode { float coef;//系数 int expn;//指数 struct Lnode *next; } Lnode,*Linknode; void init(Linknode &L) //初始化L { L=(Linknode)malloc(sizeof(Linknode)); L->next=NULL; } void
第二章王道数据结构练习题12-14题--7/21
qq_41218103的博客
07-21 217
#include<stdio.h> #include<stdlib.h> typedef struct DNode { int data; struct DNode *next; } DNode,*DLinklist; void init(DLinklist &L) //初始化链表 利用前插法 { int x=0; L=(DLinklist)malloc(sizeof(DNode)); L->next=NULL; printf("请输入
队列
qq_41218103的博客
07-25 172
顺序队列 注意：（1）进队操作要先判断栈是否满（由于顺序队列不好判断 −>->−>循环队列） （2） 先将数据放入尾指针所指的数组，再尾指针++。 L.data[L.rear]=e ; L.rear++; void init(squeue &L) //初始化 { L.front=L.rear=0; } bool enter(squeue &L,int e) { if (队满) return false; L.data[L.r.
王道第二章综合应用题2-8题 ---------7/20
qq_41218103的博客
07-20 166
//第二章第二题 //第二章第二题 #include<stdio.h> #include<stdlib.h> typedef struct DNode { int data; struct DNode *next; } DNode,*DLinklist; void init(DLinklist &L) //初始化链表 利用前插法 { int x=0; L=(DLinklist)malloc(sizeof(DNode)); L->next
第二章线性表王道练习题统考题
qq_41218103的博客
07-22 159
21.（p43）思路： 定义p,q指针，初始时均指向头结点的下一个结点，令p结点向下移动当p节点移动到第k个节点时，q指针开始与p指针一起移动。这样当p指针移动到最后一个是q指针指向倒数第k个节点 int find_font(DLinklist L) { int k=1,count=0; printf("请输入k：\n"); scanf("%d",&k); DLinklist p=L->next,q=L->next; while(p!=NULL) {
二叉树操作算法详解
"二叉树相关的C语言实现代码，包括初始化、创建、遍历等基本操作" 二叉树是一种在计算机科学中广泛使用的数据结构，它由节点（或称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值