二叉树的常见考法1

已于 2022-10-05 20:12:49 修改
阅读量353 收藏 6
点赞数 1
分类专栏： 有点难啊，，得多看看 我的学习笔记 文章标签： 开发语言 c++ 算法 数据结构
于 2022-07-15 11:57:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gong_zc/article/details/125800614
版权

二叉树结构体（带权重，父节点）

//二叉树的定义
typedef struct BNode{
	int data;
	struct BNode *lchild,*rchild,*parent;
	//二叉树的权重 
	int weight;
}BNode,*BiTree;

创建二叉树

BiTree createBiTree(){
	int data;
	scanf("%d",&data);
	if(data!=-1){
		BiTree t  = (BiTree)malloc(sizeof(BNode));
		t->data = data;
		t->lchild = createBiTree();
		//父节点建立 
		if(t->lchild!=NULL){
			t->lchild->parent = t;
		}
		t->rchild = createBiTree();
		if(t->rchild!=NULL){
			t->rchild->parent = t;
		}
		//权重节点建立 
		if(!t->lchild && !t->rchild){
			scanf("%d",&data);
			t->weight = data;
		}
		return t;
	}else{
		return NULL;
	}
}

 

先温习一下遍历方式

三大遍历 递归版

//前序递归法 
void preOrder(BiTree t){
	if(t==NULL)return;
	visit(t);
	preOrder(t->lchild);
	preOrder(t->rchild);
}
//中序递归法
void inOrder(BiTree t){
	if(t==NULL)return;
	inOrder(t->lchild);
	visit(t);
	inOrder(t->rchild);
}
//后续递归法
void postOrder(BiTree t){
	if(t==NULL)return;
	postOrder(t->lchild);
	postOrder(t->rchild);
	visit(t);
}

三大遍历 非递归版

//前序非递归
void upreOrder(BiTree t){
	BiTree Stack[MaxSize],p=t;
	int top = -1;
	while(p || top!=-1){
		if(p){
			visit(p);
			Stack[++top] = p;
			p = p->lchild;
		}else{
			p = Stack[top--];
			p = p->rchild;
		}
	}
}
//中序非递归
void uinOrder(BiTree t){
	BiTree Stack[MaxSize],p=t;
	int top = -1;
	while(p || top!=-1){
		if(p){
			Stack[++top] = p;
			p = p->lchild;
		}else{
			p = Stack[top--];
			visit(p);
			p = p->rchild;
		}
	}
} 
//后续非递归 
void upostOrder(BiTree t){
	BiTree Stack[MaxSize],p=t;
	int top=-1,tag[MaxSize]={0};
	while(p || top!=-1){
		if(p){
			Stack[++top] = p;
			tag[top] = 1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top] = 2;
				p = p->rchild;
			}else{
				visit(p);
				top--;
				p = NULL;
			}
		}
	}
}

层序遍历（借助队列）

void leverOrder(BiTree t){
	BiTree Queue[MaxSize],p=t;
	int front=-1,rear=front;
	Queue[++rear] = p;
	while(front!=rear){
		p = Queue[++front];
		visit(p);
		if(p->lchild){
			Queue[++rear] = p->lchild;
		}
		if(p->rchild){
			Queue[++rear] = p->rchild;
		}
	}
}

考法1：给出二叉树自下而上，自右到左的层次遍历算法

思路：层序遍历，利用栈先进后出的特性，用栈存储内容，最后将栈内内容弹出即为题目要求。

代码：

void reversePrintBiTree(BiTree t){
	BiTree Stack[MaxSize],Queue[MaxSize],p=t;
	int top=-1,front=-1,rear=front;
	Queue[++top] = p;
	while(front!=rear){
		p = Queue[++front];
		Stack[++top] = p;
		if(p->lchild){
			Queue[++rear] = p->lchild;
		}
		if(p->rchild){
			Queue[++rear] = p->rchild;
		}
	}
	while(top!=-1){
		p = Stack[top--];
		visit(p);
	}
}

考法2：递归算法求解二叉树的高度

思路：先序遍历，只不过这回要加返回值，高度取左右子树中的最大值。

代码：

int getHeight(BiTree t){
        if(!t){
          return 0;
		}
		int left = getHeight(t->lchild);
		int right = getHeight(t->lchild);
		return left>right?left+1:right+1;
}

考法3：非递归方法求解树的高度

思路：后序非递归遍历，因后续遍历的特点是祖先全在栈内，这时只需要记录top指针的数值并比较即可

代码：

//3.非递归方法求解树的高度
int ugetHeight(BiTree t){
	BiTree Stack[MaxSize],p=t;
	int top = -1,max = -1,tag[MaxSize]={0};
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				//叶子节点判断 
				if(!p->lchild && !p->rchild){
					//深度最大更新
					if(top+1>max)max = top + 1;
				}
				top--;
				p = NULL;
			}
		}
	}
	return max; 
}

考法4：求解二叉树的结点所在的层

思路：后序遍历，看栈内元素即可

代码：

int getLever(BiTree t,int data){
	BiTree Stack[MaxSize],p = t;
	int top = -1,tag[MaxSize]={0};
	while(p || top!=-1){
		if(p){
			Stack[++top] = p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				p = Stack[top];
				p = p->rchild;
				tag[top]=2;
			}else{
				if(data == p->data){
					return top+1;
				}
				top--;
				p = NULL;
			}
		}
	} 
}

以下题目基本上都利用遍历的递归思想，不再解释思路，读者请自行考虑

考法5：用递归方法求解树的结点所在的层

代码：

//5.用递归方法求解树的结点所在的层
void getLeverByR(BiTree t,int data,int &lever,int deep){
	if(t){
		//找到值了，保存值 
		if(t->data==data)lever = deep;
		//每次下降深度都得加一 
		getLeverByR(t->lchild,data,lever,deep+1);
		getLeverByR(t->rchild,data,lever,deep+1);
	}
}

考法6：使用递归方法求解树的高度（深度）

代码：

void getHeightByR(BiTree t,int curdeep,int &deep){
	if(t){
		//确认叶子节点 
		if(!t->lchild && !t->rchild){
			if(curdeep+1>deep){
			   deep = curdeep;
		  }
		}
		getHeightByR(t->lchild,curdeep + 1,deep);
	    getHeightByR(t->rchild,curdeep + 1,deep);
	}
	
}

考法7：用层序遍历求解树的高度

思路：层序遍历下每走完一层即树的高度加一即可！重要的是什么时候层序遍历什么时候算走完一层？可以先设置一个值deep=0，当front=deep时即走完一层并更新deep=rear

代码：

//7.使用层序遍历求解树的高度
int getHeightByLever(BiTree t){
	BiTree Queue[MaxSize],p = t;
	int front=-1,rear=front,height=0,deep=0;
	Queue[++rear]=p;
	while(rear!=front){
		p = Queue[++front];
		if(p->lchild){
			Queue[++rear] = p->lchild;
		}
		if(p->rchild){
			Queue[++rear] = p->rchild;
		}
		//检查当前层是否走完
		//当前层走完了，此时下一层所有元素应该已在队列中
		//这时保存队列最后一个位置，用于判断接下来一层什么时候遍历完成 
		if(deep == front){
			height++;
			deep = rear;
		}
	}
	return height;
}

考法8：求解树的宽度 （最大宽度）

思路：层序遍历取最大值

代码：

int getWidthByLever(BiTree t){
	BiTree Queue[MaxSize],p = t;
	int front=-1,rear=front,deep=0,maxwidth=-1;
	Queue[++rear]=p;
	while(rear!=front){
		p = Queue[++front];
		if(p->lchild){
			Queue[++rear] = p->lchild;
		}
		if(p->rchild){
			Queue[++rear] = p->rchild;
		}
		//检查当前层是否走完
		//当前层走完了，此时下一层所有元素应该已在队列中
		//这时保存队列最后一个位置，用于判断接下来一层什么时候遍历完成 
		if(deep == front){
        //队列长度更新
			if(rear - front >maxwidth){
				maxwidth = rear - front;
			}
			deep = rear;
		}
	}
	return maxwidth;
}

考法9：判断一棵树是否是一颗完全二叉树

思路：层序遍历，完全二叉树的特性：完全二叉树一层遍历完队列里应该无节点
如果有则证明有空节点，后面仍有多余节点，不是完全二叉树

代码：

bool isATBiTree(BiTree t){
	BiTree Queue[MaxSize],p = t;
	int front=-1,rear=front,deep=0;
	Queue[++rear]=p;
	while(rear!=front){
		p = Queue[++front];
		if(p){
			Queue[++rear] = p->lchild;
			Queue[++rear] = p->rchild;
		}else{
			//完全二叉树一层遍历完队列里应该无节点
			//如果有则证明有空节点，后面仍有多余节点，不是完全二叉树 
			while(front!=rear){
				p = Queue[++front];
				if(p)return false;
			}
		}
	}
	return true;
}

考法10：计算二叉树的所有双分支节点个数
求单分支节点
求叶子节点

代码： 

void getNodeCount(BiTree t,int &n){
	if(t){
		//叶子节点 
		if(!t->lchild && !t->rchild){
		    n++;
	    } 
	    //单分支 
//	    if(!t->lchild && t->rchild || t->lchild && !t->rchild){
//		    n++;
//	    } 
	    //双分支
//		 if(t->lchild && t->rchild){
//		    n++;
//	    } 
	getNodeCount(t->lchild,n);
	getNodeCount(t->rchild,n);
	}
}

考法11：递归返回方法求解树的双节点数

代码：

//11.递归返回方法求解树的双节点数
int getDNodeByR(BiTree t){
	if(!t)return 0;
	//双分支节点加一 
	else if(t->lchild && t->rchild) return 1+getDNodeByR(t->lchild) + getDNodeByR(t->rchild);
	else return getDNodeByR(t->lchild) + getDNodeByR(t->rchild);
}

考法12：使用非递归方法交换左右子树

思路：层序遍历，对子树一个个交换即可

代码：

void swaplrchild(BiTree &t){
	BiTree Queue[MaxSize],p = t,temp;
	int front=-1,rear = front,deep=0;
	Queue[++rear] = p;
	while(front!=rear){
		p = Queue[++front];
		//开始交换
		temp = p->lchild;
		p->lchild = p->rchild;
		p->rchild = temp;
		//继续入队 
		if(p->lchild)Queue[++rear] = p->lchild;
		if(p->rchild)Queue[++rear] = p->rchild;	
	}
}

考法13：使用递归方法交换左右子树

代码:

void swaplrchildByR(BiTree &t){
	if(t){
		//顺序不一致是否结果不一样呢？ 
		BiTree temp = t->lchild;
	    t->lchild = t->rchild;
	    t->rchild = temp;
		if(t->lchild)swaplrchildByR(t->lchild);
		if(t->rchild)swaplrchildByR(t->rchild);
	}
}

考法14：先序遍历序列中第k个节点的值

代码：

void preOrderGetK(BiTree t,int k,int &deep,int &data){
	if(t){
		if(k==deep){
			data = t->data;
		}
		deep = deep + 1;
		preOrderGetK(t->lchild,k,deep,data);
		preOrderGetK(t->rchild,k,deep,data);
	} 
}

非递归实现：

int  upreOrderGetK(BiTree t,int k){
	BiTree Stack[MaxSize],p=t;
	int top = -1,count = 0;
	while(p || top!=-1){
		if(p){
			if(count == k)return p->data;
			count ++;
			Stack[++top] = p;
			p = p->lchild;
		}else{
			p = Stack[top--];
			p = p->rchild;
		}
	}
	return -1;
}

考法15：中序遍历序列中第k个节点的值

代码：

void inOrderGetK(BiTree t,int k,int &deep,int &data){
	if(t){
		inOrderGetK(t->lchild,k,deep+1,data);
		if(k==deep){
			data = t->data;
		}
		inOrderGetK(t->rchild,k,deep+1,data);
	} 
}

非递归实现：

int uinOrderGetK(BiTree t,int k){
	BiTree Stack[MaxSize],p=t;
	int top = -1,count = 0;
	while(p || top!=-1){
		if(p){
			Stack[++top] = p;
			p = p->lchild;
		}else{
			p = Stack[top--];
			if(count == k)return p->data;
			count ++;
			p = p->rchild;
		}
	}
	return -1;
}

考法16：后序遍历序列中第k个节点的值

代码：

void postOrderGetK(BiTree t,int k,int &deep,int &data){
	if(t){
		postOrderGetK(t->lchild,k,deep+1,data);
		postOrderGetK(t->rchild,k,deep+1,data);
		if(k==deep){
			data = t->data;
		}
	} 
}

非递归实现：

int upostOrderGetK(BiTree t,int k){
	BiTree Stack[MaxSize],p=t;
	int top = -1,count = 0,tag[MaxSize] = {0};
	while(p || top!=-1){
		if(p){
			Stack[++top] = p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				p = p->rchild;
				tag[top]=2;
			}else{
				if(count == k)return p->data;
			    count ++;
				top--;
				p = NULL;
			}
		}
	}
	return -1;
}

考法17：层次遍历序列中第k个节点的值

代码：

int leverOrderGetK(BiTree t,int k){
	BiTree Queue[MaxSize],p=t;
	int rear = -1,front = rear,count = 0;
	Queue[++rear] = p;
	while(rear!=front){
		p = Queue[++front];
		if(k == count)return p->data;
		count++;
		if(p->lchild)Queue[++rear] = p->lchild;
		if(p->rchild)Queue[++rear] = p->rchild;
	}
	//别忘记找不到返回-1 
	return -1;
}

考法18：除树中每个元素值为x的节点，并删除以它为根的子树

代码：

void deleteNodeByPost(BiTree &t){
	if(t){
		deleteNodeByPost(t->lchild);
		deleteNodeByPost(t->rchild);
		free(t);
	}
}
//层序遍历，寻找x节点 
void findXandDelete(BiTree &t,int data){
	BiTree Queue[MaxSize],p = t;
	int rear = -1,front = rear;
	while(rear!=front){
		p = Queue[++front];
//		if(p->data == x){
//		   deleteNodeByPost(t);
//		   p = NULL; 
//		} 
        if(p->lchild && p->lchild->data = x){
        	deleteNodeByPost(p->lchild);
        	p->lchild = NULL;
		}
		if(p->rchild && p->rchild->data = x){
        	deleteNodeByPost(p->rchild);
        	p->rchild = NULL;
		}
		if(p->lchild)Queue[++rear] = p->lchild;
		if(p->rchild)Queue[++rear] = p->rchild; 
	}
}

考法19：打印节点x的所有的祖先

思路：后序遍历时找到节点k此时祖先节点已全在栈内，打印栈内所有元素即可！

代码：

void printAllPNode(BiTree t,int x){
	BiTree Stack[MaxSize],p = t;
	int top = -1,tag[MaxSize] = {0};
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				//检查节点值是否是x 
				if(x == p->data){
					int i = top;
					while(i!=-1){
						i--;
						printf("%d,",Stack[i]->data);
					}
				}
				top--;
				p = NULL;
			}
		}
	}
}

考法20：打印从根节点到某个节点的路径

思路：类似于上一题

代码：

void printRoutine(BiTree t,int x){
	BiTree Stack[MaxSize],p = t;
	int top=-1,tag[MaxSize]={0};
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				if(p->data = x){
					for(int i=top;i!=-1;i--){
						printf("%d,",Stack[i]);
					}
				}
				top--;
				p = NULL;
			}
		}
	}
}

以下代码基本采用的都是后序遍历的思路，读者请自行测试！不再阐述思路。 

考法21：求从根节点到某个节点的路径长度 （最大） 

思路：后序遍历，取栈的最大长度即可

代码：

int printRoutine(BiTree t,int x){
	BiTree Stack[MaxSize],p = t;
	int top=-1,tag[MaxSize]={0};
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				if(p->data = x){
					return top+1;
				}
				top--;
				p = NULL;
			}
		}
	}
}

考法22：根节点到某个节点最大路径长度

代码：

int printRoutine(BiTree t,int x){
	BiTree Stack[MaxSize],p = t;
	int top=-1,tag[MaxSize]={0},maxdeep=-1;
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				if(p->data = x){
					if(top+1>maxdeep) maxdeep=top+1;
				}
				top--;
				p = NULL;
			}
		}
	}
	return maxdeep;
}

考法23：判断u是否为v的后代 v是为u的祖先

代码：

bool printRoutine(BiTree t,BiTree u,BiTree v){
	BiTree Stack[MaxSize],p = t;
	int top=-1,tag[MaxSize]={0},maxdeep=-1;
	while(p || top!=-1){
		if(p){
			Stack[++top]=p;
			tag[top]=1;
			p = p->lchild;
		}else{
			p = Stack[top];
			if(tag[top]==1){
				tag[top]=2;
				p = p->rchild;
			}else{
				if(p==v){
					for(int i=top;i!=-1;i--){
						if(Stack[i]==v)return true;
					}
				}
				top--;
				p = NULL;
			}
		}
	}
	return false;
}

考法24：判断两颗二叉树是否相似

思路：相似是指树的形状相似，两棵树同时遍历，如果有树的结点先没有即代表两棵树不相似

代码：

bool issimilar(BiTree u,BiTree v){
	if(!u || !v)return false;
	else if(!u && !v)return true;
	else return issimilar(u->lchild,v->lchild) && issimilar(u->rchild,v->rchild);
}

考法25：判断两颗二叉树是否相等 

思路：在上述题目的基础上增加对结点数据的判断即可

代码:

bool isequal(BiTree u,BiTree v){
	if(!u || !v)return false;
	else if(!u && !v)return true;
	else if(u->data!=v->data)return false;
	else return issimilar(u->lchild,v->lchild) && issimilar(u->rchild,v->rchild);
}

考法26：将叶子节点串成一个单链表，用叶子节点的rchild，作next

思路：对叶子节点判断形成一条单链表即可

代码：

void getLeafChain(BiTree &pre,BiTree &p){
	if(p){
		if(!p->lchild && !p->rchild){
			if(!pre){
				pre = p;
			}else{
				pre->rchild = p;
			    pre = p;
			}
		}
		getLeafChain(pre,p->lchild);
		getLeafChain(pre,p->rchild);
	}
}

考法27：带权结点路径计算

代码：

void getWPL(BiTree t,int &deep,int &wpl){
	if(t){
		if(!t->lchild && !t->rchild){
			wpl += (deep-1)*t->weight;
		}
		getWPL(t->lchild,deep+1,wpl);
		getWPL(t->rchild,deep+1,wpl);
	}
}

考法28：在中序线索二叉树中查找指定节点在后序里面的前驱

思路：分为三种情况：

  1. 是否有右子树，有则直接是后续遍历的前驱
  2. 无右子树是否有左子树，有则直接是后续遍历的前驱
  3. 既无右子树也无左子树，基于中序线索遍历的特性向上查找一个含有左子树的父节点，这个节点的左孩子即为后续遍历的前驱

代码：

ThreadTree inOrderFindPrePPost(ThreadTree p){
	//p有右孩子，返回右孩子 
	if(p->rtag == 0)return p->rchild;
	//p有左孩子，无右孩子，返回左孩子 
	else if(p->ltag == 0)return p->lchild;
	//p无左右孩子，则后续的前驱一定是他的父亲节点或爷爷节点
	//此时在中序线索序列里则为他的左指针域,且如果有线索则不停向上访问，
	//遍历,直到有一个祖先有左孩子，则这个左孩子一定是后序遍历p的前驱。
	else{
		while(p->lchild && p->ltag==1){
			p = p->lchild;
		} 
		if(p->ltag == 0)return p->lchild;
		else return NULL;
	}
}

以上代码仅供参考，如有错误恳请指正，谢谢！

 

 

乐公同学
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的遍历及基本运算
escFAJ的博客
08-09 1968
二叉树的遍历及基本运算 一、实验目的： 1.深入理解二叉树的基本概念和递归程序设计方法。 2.熟练掌握二叉树在二叉链表存储结构中的常用遍历方法：先序、中序、后序递归遍历，了解先序、中序和后序非递归遍历及层序遍历。 3.用二叉树解决实际问题，如掌握构造哈夫曼树及其编码和译码的方法。 二、实验内容： 1.建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果； 2.建立一棵二叉树，求二叉数的树的深度、统计叶子结点的个数、统计总的结点个数、进行层序遍历、交换左右子树等； 3.哈夫曼编码译码系统。 三
C语言二叉树操作处理(初稿)
knighkingLOL的博客
08-01 262
#include<stdio.h> #include<stdlib.h> #define MaxSize 10 typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; void PreOrderTraverse(BiTree T)//二...
如何交换二叉树的左右子树?
weixin_46899589的博客
11-11 566
题目：试编写一个算法将一颗二叉树的所有节点的左右子树进行交换。 分析： 我们仍然可以采用递归的方式进行交换。 代码如下： struct biTree { char data; struct biTree *lchild; struct biTree *rchild; }; void swapTree(biTree &T) { //交换二叉树每个结点的左孩子和右孩子 if (!T) return; if (!T->lchild &&!T->rchild) //如果左右子树有
二叉树的基本操作C语言详解
热门推荐
学习笔记，仅供参考
03-25 1万+
1、链表结构代码 typedef struct Node { char data; //数据域 struct Node* Lchild, * Rchild; //左右孩子指针 }BTNode,*BTree; 2、创建二叉树 int CreateBTree(BTree* T) { char ch; scanf("%c", &ch); if (ch == '#'...
二叉树及其基本功能的实现
AlberTesla的博客
10-14 311
二叉树及其基本功能的实现 #include<bits/stdc++.h> using namespace std; struct BinTree { int data; BinTree* lchild; BinTree* rchild; }; //创建一棵二叉树 int create(BinTree*(&T)) { int num; cin>>num; if(num==-1) { T=NULL;
leetcode 二叉树-1
02-09
例如，深度为h的完全二叉树的节点数范围是从1到2^(h-1)。 2. **二叉搜索树（BST）**： - 二叉搜索树是一种特殊的二叉树，其中每个节点的左子树只包含小于该节点值的节点，右子树包含大于该节点值的节点。这样保证...
二叉树常见的一些操作算法实现
04-06
内容概要：通过c语言以及队列的知识，用c代码完成二叉树的构建、销毁、遍历、高度、密度、添加、删除、查询、求左、求右、求根等操作 ...能学到什么：掌握二叉树的一些常见的基本算法，有助于后续的算法结构学习
二叉树的考研常见问题代码
03-09
408考试二叉树习题答案. 主要有递归和非递归二种写法.
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树题目列表1
08-08
以下是一些关于二叉树的常见问题和解决方案： 1. **求二叉树中的节点个数**：通过递归方法，若树为空返回0，否则返回左子树节点数+右子树节点数+1。 2. **求二叉树的深度**：同样使用递归，若树为空则深度为0，...
C语言学习——二叉树（二）
cainiao000001的博客
01-21 396
二叉树相关代码： 创建二叉树 Status CreateTree(BiTree*T) { TElemType ch; ch = str[zb++]; if(ch == '#')//判出条件 return 0; *T = (BiTree)malloc(LONG); if(!*T) return ERROR; (*T)->data = ch; CreateTree(&((*T)
c++数据结构--树与二叉树详解
qq_60462402的博客
05-03 1487
树的定义 树（tree）是n（n>=0）个结点的有限集，它或为空树（n=0）；或为非空树，对于非空树T: (1)有且仅有一个称之为根的结点； (2)除根以外的其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树。 树的结构定义是一个递归的定义，即在树的定义中又用到树的定义，它道出了树的固有特性。 下面介绍一些树形结构中的基本术语。 树的基本术语 **结点：**树中的一个独立单元，包含一个数据元素及若干指向其子树的分支，如上图中的R、
c语言实现二叉树基本操作
qingshanlvshui9的博客
11-22 1787
/* 本实验为二叉树的补充实验，主要实现14个操作： 1、void CreatBitree(BiTree &T) //输入二叉树的先序遍历序列（空树用字符'#'表示），创建二叉链表T 2、bool level(BiTree T,char ch,int curlevel,int &p) //（已实现）求二叉树T中值为ch的结点的层次，结果用p表示 3、bool ancestor(BiTree T,char ch) //（已实现）在二叉树T中求值为ch的结点的祖先,成功返回true
先根遍历二叉树c语言程序,c语言实现二叉树(BiNodeTree)的建立与先序遍历,中序遍历...
weixin_34223354的博客
05-17 371
#include #include typedef struct BiNode {char data;struct BiNode *lchild, *rchild;}BiNode;BiNode *CreateBiTree(BiNode *T) {char data;scanf("%c", &data);if((data=='#')||(data=='/n')) {T = NULL;} el...
遍历二叉树应用
孙飞(Java)
04-23 578
void CountLeaf(BiTree &T,int &count){ if(T){ if(（!T->lchild）&&(!T->rchild)) count++; CountLeaf(T->lchild,count); CountLeaf(T->rchild,count); } } 1.统计二叉树叶子节点的个数（先序遍历） int Depth(BiTree T){ i
数据结构（五）——队列、树
一个电子信息嵌入式的学习笔记
02-16 376
队列与树
DS 0929（第五章 二叉树）
INF0817的博客
09-29 423
二叉树 或者为空二叉树 或者是一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一颗二叉树。 特点 每个结点之多有两颗子树 左右子树不可以颠倒（二叉树是有序树） 注意与度为二的有序树的区别 几个特殊的二叉树 满二叉树 特点： 只有最后一层有叶子结点， 不存在度为1的结点， 按层序从1开始编号，结点i的左孩子为2i，右孩子为2i+1；结点i的父节点为i/2 完全二叉树 特点： 只有可能在最后两层出现叶子结点, 最多只有一个度为1的结点 同满二叉树子节点，父节点算
数据结构 作业答案 第5章 树和二叉树
HKD_WCY的博客
06-14 7593
第5章 树和二叉树 1．选择题 （1）把一棵树转换为二叉树后，这棵二叉树的形态是（ ）。 A．唯一的 Ｂ．有多种 C．有多种，但根结点都没有左孩子 Ｄ．有多种，但根结点都没有右孩子 答案：A 解释：因为二叉树有左孩子、右孩子之分，故一棵树转换为二叉树后，这棵二叉树的形态是唯一的。 （2）由3个结点可以构造出多少种不同的二叉树？（ ） A．2 B．3 C．4 D．5 答案：D 解释：
19版考研数据结构王道课后习题代码-树 下【未完】
努力努力再努力0.0的博客
10-09 212
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
完全二叉树冒泡排序常见错误
最新发布
09-27
完全二叉树冒泡排序的常见错误是在排序过程中未正确对父节点、左子节点和右子节点进行比较和交换。在完全二叉树中，父节点的索引为i，左子节点的索引为2i，右子节点的索引为2i+1。因此，在冒泡排序的过程中，应该对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值