【二叉树的题2】

已于 2022-05-14 11:39:39 修改
阅读量3.5k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++
于 2022-05-04 17:44:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cherryDarling7/article/details/124528343
版权

注意 ! 这里主要是帮助博主自己复习hhhhh

目录

判断是否是完全二叉树

 删除一个节点

 层序存储输出前序

前序中序推后序 

 求二叉树的镜像

求第K层结点数 

完全二叉树：后序推层序遍历

判断是否是完全二叉树

根据提示借助层序遍历，针对几种情况进行判断。

//判断是否是完全二叉树 
bool BiTree::isWanquan(BiNode* bt){
	BiNode* p;
	queue<BiNode*> Q;
	Q.push(bt);
	int a1=0,a2=0;  //a1是第二种情况，a2是第三种情况 
	while(!Q.empty()){
		p=Q.front();
		Q.pop(); 
		if(a1==1||a2==1)   //需要判断 
			if(!(p->lchild==NULL&&p->rchild==NULL)){
				return false;
			}
		if(p->rchild!=NULL&&p->lchild==NULL){
			return false;
		}
		if(p->lchild!=NULL&&p->rchild==NULL) a1=1;          //有左孩子无右孩子：需要判断后续是否全为叶子节点 
		if(p->lchild==NULL&&p->rchild==NULL) a2=1;          //是叶子节点，如上 
		if(p->lchild!=NULL) Q.push(p->lchild);
		if(p->rchild!=NULL) Q.push(p->rchild);
	}
	return true;
}

 删除一个节点

能A的代码是从父节点判断左右孩子是否匹配，这里就存在根节点没有父节点这个需要特判的情况了

我比较有问题的是，为什么不能直接判断当前节点是否匹配，然后删除呢??

//删除结点
void  BiTree::del(BiNode* bt,char ch){
	// if(root==NULL) return;
	// if(root->data==ch){
	// 	root=NULL;
	// 	return;
	// }
	// if(bt->lchild!=NULL){
	// 	if(bt->lchild->data==ch) bt->lchild=NULL;
	// 	else del(bt->lchild,ch);
	// }
	// if(bt->rchild!=NULL){
	// 	if(bt->rchild->data==ch) bt->rchild=NULL;
	// 	else del(bt->rchild,ch);
	// }
	// return;
    //我不理解为什么这里不行？
	if(bt==NULL) return;
	if(bt->data==ch) bt==NULL;
	else{
		del(bt->lchild,ch);
		del(bt->rchild,ch);
	}
	return;
}

 层序存储输出前序

下标从1开始 

左：2*i

右：2*i+1

下标从0开始

左：2*i+1

右：2*i+2

下标超出范围的时候返回。

//使用数组对二叉树进行存储
#include<iostream>
#include<string.h>
using namespace std;
const int N=1e5+10;
char q[N]={0};
int len;
void print(int i){
	if(i>len-1) return;
	if(q[i]!='^') printf("%c",q[i]);
	print(i*2+1);     //左边 
	print(i*2+2);   //右边 
}

int main(){
	scanf("%s",q);
	len=strlen(q);
	print(0); 
}

前序中序推后序 

前序：根->左->右

中序：左->根->右

后序：左->右->根

一些说明：

1.基本思路：在中序中找到根节点，左边即为根节点的左子树，右边为右子树。先递归左子树再递归右子树，最后打印该根节点。

存储根节点，创建左子树，创建右子树。

2.使用了string类里面的find()和substr()函数

find():找到括号内的第一次出现参数的位置并返回其下标

substr():截取数组，左闭右开

这段代码使用链表的方式创建了二叉树，再对其进行后序遍历

#include<iostream>
#include<string>
using namespace std;
typedef struct Tree{
	char data;
	struct Tree *lchild,*rchild; 
}Node,*BTree; 

void build(BTree &T,string str1,string str2){
	if(str1.size()==0&&str2.size()==0) T=NULL;
	else{
		T=new Node;
		T->data=str1[0];
		int pos=str2.find(str1[0]);
		string str_L1=str1.substr(1,pos);
		string str_R1=str1.substr(pos+1,str1.length());
		string str_L2=str2.substr(0,pos);
		string str_R2=str2.substr(pos+1,str2.length());
		build(T->lchild,str_L1,str_L2);
		build(T->rchild,str_R1,str_R2);
	}
	return;
}

void postPrint(BTree T){
	if(T==NULL) return;
	postPrint(T->lchild);
	postPrint(T->rchild);
	cout<<T->data;
}

int main(){
	BTree T;
	string str1,str2;
	cin>>str1;
	cin>>str2;
	build(T,str1,str2);
    cout<<"后序遍历：";
	postPrint(T);
	return 0;
}

这里还有一种为了快速应考的代码

 思路是上面那个删除线部分

#include<iostream>
#include<string>
string a,b;//a是前序，b是中序
void build(int l1,int r1,int l2,int r2){
    for(int i=0;i<=r2;i++){
        if(a[l1]==b[i]){
            build(l1+1,r1,l2,i-1);
            build(l1+i-l2+1,r1,i+1,r2);
            cout<<a[i];
        }
    }
    return;

}
int main(){
    cin>>a>>b;
    int r=a.size()-1;
    build(0,r,0,r);

}

 求二叉树的镜像

 

#include<iostream>
#include<stdio.h>
#include<string.h>
const int MAX=1000;
using namespace std;
struct BiNode
{
    char data;//数据域
    BiNode  *lchild, *rchild;//左右儿子指针
};

class BiTree {
private:
  BiNode *root;  
public:
	BiNode* getRoot(){return root;}
	BiTree(){root=creat(root);}
	BiNode* creat(BiNode* bt);
	void trans(BiNode* bt);
	void prePrint(BiNode* bt);
};

BiNode *BiTree::creat(BiNode* bt){
	char ch;
	cin>>ch;
	if(ch=='#') bt=NULL;
	else{
		bt=new BiNode;
		bt->data=ch;
		bt->lchild=creat(bt->lchild);
		bt->rchild=creat(bt->rchild);
	}
	return bt;
}
void BiTree::trans(BiNode* bt){
	if(bt==NULL) return;
	if(bt->lchild!=NULL&&bt->rchild!=NULL){
		BiNode* p=bt->lchild;
		bt->lchild=bt->rchild;
		bt->rchild=p;
	}
	if(bt->lchild!=NULL) trans(bt->lchild);
	if(bt->rchild!=NULL) trans(bt->rchild); 
	return;
}
void BiTree::prePrint(BiNode* bt){
	if(bt==NULL) return;
	cout<<bt->data;
	prePrint(bt->lchild);
	prePrint(bt->rchild); 
}
int main(){
	BiTree tree;
	tree.trans(tree.getRoot());
  cout<<"镜像后二叉树的前序遍历序列是：";
	tree.prePrint(tree.getRoot());
	return 0;
	
}

 将左右孩子交换

求第K层结点数 

 两种方法：

递归：

定义一个全局变量初值为0.

传参k,每次访问子树（下一层）时就在传参时将k-1,当k=1时，就说明在该节点在第k层，num++

(所以每次访问之前都要判断左右孩子是否为空，为空就不能访问)

void BiTree::getNode_Num1(BiNode* bt,int k){
	if(k==1){
		num++;
		return;
	}
	else{
		if(bt->lchild!=NULL) getNode_Num1(bt->lchild,k-1);
		if(bt->rchild!=NULL) getNode_Num1(bt->rchild,k-1);
		return;
	}
}

迭代：

 又是利用层序遍历，记录该层的总个数，将该层访问完（边访问边入队）。每次访问完一层后，层数++，若当前层数等于所求层数，就返回记录的该层总个数

int GetKthLevelNodesTotal( BTreeNode_t *pRoot, unsigned int KthLevel ){
    if( pRoot == NULL )
        return 0;
 
    queue <BTreeNode_t *>  que;
    que.push( pRoot );
    int curLevelNodesTotal = 0;
    int curLevel = 0;
   
    while( !que.empty() ){
        ++curLevel;//当前层数
        curLevelNodesTotal = que.size();
        if( curLevel == KthLevel )//如果层数等于给定层数
            break;
 
        int cntNode = 0;
        while( cntNode < curLevelNodesTotal){//将下一层节点入队
            ++cntNode;
            pRoot = que.front();
            que.pop();
            if( pRoot->m_pLeft != NULL )
                que.push(pRoot->m_pLeft);
            if( pRoot->m_pRight != NULL )
                que.push( pRoot->m_pRight);
        }
    }
    
    while ( !que.empty() )
        que.pop();
 
    if( curLevel == KthLevel )
        return curLevelNodesTotal;
    return 0;  //如果KthLevel大于树的深度
}

 总的代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
const int MAX=1000;
using namespace std;
int num=0;
struct BiNode
{
    char data;//数据域
    BiNode  *lchild, *rchild;//左右儿子指针
};

class BiTree {
private:
  BiNode *root;  
public:
	BiNode* getRoot(){return root;}
	BiTree(){root=creat(root);}
	BiNode* creat(BiNode* bt);
	void trans(BiNode* bt);
	void prePrint(BiNode* bt);
	void getNode_Num1(BiNode* bt,int k);
};

BiNode *BiTree::creat(BiNode* bt){
	char ch;
	cin>>ch;
	if(ch=='#') bt=NULL;
	else{
		bt=new BiNode;
		bt->data=ch;
		bt->lchild=creat(bt->lchild);
		bt->rchild=creat(bt->rchild);
	}
	return bt;
}
void BiTree::trans(BiNode* bt){
	if(bt==NULL) return;
	if(bt->lchild!=NULL&&bt->rchild!=NULL){
		BiNode* p=bt->lchild;
		bt->lchild=bt->rchild;
		bt->rchild=p;
	}
	if(bt->lchild!=NULL) trans(bt->lchild);
	if(bt->rchild!=NULL) trans(bt->rchild); 
	return;
}
void BiTree::prePrint(BiNode* bt){
	if(bt==NULL) return;
	cout<<bt->data;
	prePrint(bt->lchild);
	prePrint(bt->rchild); 
}
void BiTree::getNode_Num1(BiNode* bt,int k){
	if(k==1){
		num++;
		return;
	}
	else{
		if(bt->lchild!=NULL) getNode_Num1(bt->lchild,k-1);
		if(bt->rchild!=NULL) getNode_Num1(bt->rchild,k-1);
		return;
	}
}
int main(){
	BiTree tree;
	int k;
	cin>>k;
	tree.getNode_Num1(tree.getRoot(),k);
	cout<<num;
//	tree.trans(tree.getRoot());
//  cout<<"镜像后二叉树的前序遍历序列是：";
//	tree.prePrint(tree.getRoot());
	return 0;
	
}
int GetKthLevelNodesTotal( BTreeNode_t *pRoot, unsigned int KthLevel ){
    if( pRoot == NULL )
        return 0;
 
    queue <BTreeNode_t *>  que;
    que.push( pRoot );
    int curLevelNodesTotal = 0;
    int curLevel = 0;
   
    while( !que.empty() ){
        ++curLevel;//当前层数
        curLevelNodesTotal = que.size();
        if( curLevel == KthLevel )//如果层数等于给定层数
            break;
 
        int cntNode = 0;
        while( cntNode < curLevelNodesTotal){//将下一层节点入队
            ++cntNode;
            pRoot = que.front();
            que.pop();
            if( pRoot->m_pLeft != NULL )
                que.push(pRoot->m_pLeft);
            if( pRoot->m_pRight != NULL )
                que.push( pRoot->m_pRight);
        }
    }
    
    while ( !que.empty() )
        que.pop();
 
    if( curLevel == KthLevel )
        return curLevelNodesTotal;
    return 0;  //如果KthLevel大于树的深度
}

完全二叉树：后序推层序遍历

使用数组模拟二叉树，根据完全二叉树的特点，
已知任意一种遍历，可以唯一的确定一颗完全二叉树

#include<iostream>
using namespace std;
const int N=1e5+10;
int n,m;
char postorder[N],tree[N];
int ind=1;
void gettree(int x){
	if(x>n) return;
	else{
		gettree(x*2);
		gettree(x*2+1);
		tree[x]=postorder[ind++];
	}
	return;		
} 
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>postorder[i];
	gettree(1);
	for(int i=1;i<=n;i++) printf("%c",tree[i]);
	return 0;
}


 

Moon_quakes_xi
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算二叉树的第k层中所有叶子结点个数
weixin_46638265的博客
04-21 5015
计算二叉树的第k层中所有叶子结点个数 Time Limit:1000MS Memory Limit:65535K 题型: 编程题 语言: 无限制 描述 二叉链表表示的二叉树：按先序次序输入二叉树中结点的值，’#'字符表示空树，构造二叉链表表示的二叉树T（该二叉树中的结点为单个字符并且无值重复的结点）, 编写算法完成：计算二叉树的第k层中所有叶子结点个数，根结点为第1层，根结点的孩子结点为第2...
【题解】加分二叉树
tanfuwen_的博客
10-04 2576
题目 题目描述 设一个 nnn 个节点的二叉树tree\text{tree}tree 的中序遍历为(1,2,3,\ldots,n)(1,2,3,…,n)，其中数字 1,2,3,\ldots,n1,2,3,…,n 为节点编号。每个节点都有一个分数（均为正整数），记第 ii 个节点的分数为 d_id i ​ ，\text{tree}tree 及它的每个子树都有一个加分，任一棵子树 \text{subtree}subtree（也包含 \text{tree}tree 本身）的加分计算方法如下： \text{sub
C++实现二叉树的创建、遍历、复制、深度、结点数、叶子数
qq_44757691的博客
12-06 2528
目录1.二叉链表存储结构定义2.二叉链表初始化3.二叉树的建立4.先序遍历二叉树5.中序遍历二叉树6.后序遍历二叉树7.中序非递归算法遍历二叉树8.层次遍历二叉树9.复制二叉树10.计算二叉树的深度11.计算二叉树结点总数12.计算二叉树叶子结点数13.测试 14.完整代码 2.二叉链表初始化 3.二叉树的建立 4.先序遍历二叉树 5.中序遍历二叉树 6.后序遍历二叉树 7.中序非递归算法遍历二叉树 8.层次遍历二叉树 9.复制二叉树 10
交换二叉树中每个结点的左孩子和右孩子
热门推荐
weixin_42048463的博客
05-02 1万+
在之前的博客中，我们已经掌握了二叉树先序遍历、中序遍历和后序遍历递归算法. 我们可以任选一种遍历序列作为本算法的基础，并在遍历结点时交换该结点的左右子树顺序即可. 在此，我选择先序遍历序列. 遍历序列的选择仅仅是"开胃菜"，解决本问题的核心是"如何交换某结点的左右子树顺序"：大家可以在草稿纸上画出一棵形态具有代表性(即不能过...
C语言实现把二叉树中所有结点的左、右子树进行交换的函数
呵呵哒!的博客
11-25 1685
C语言实现把二叉树中所有结点的左、右子树进行交换的函数
将二叉树的两个孩子换位置，即左变右，右变左。（递规与非递规两种方法）
YEYUANGEN的专栏
03-15 2207
将二叉树的两个孩子换位置，即左变右，右变左。(用递归和非递归两种方法) 2011-10-14 8:35 将二叉树的两个孩子换位置，即左变右，右变左。(用递归和非递归两种方法) 递归的版本： void change( BTree * pTree ) { if( NULL == pTree ) return; BTree * pTemp = pTree.l
【二叉树】关于二叉树的习题（一）
回收站
10-21 289
已知一颗有201120112011个结点的数，其叶结点个数为116116116，求该树对应的二叉树中无右孩子的结点个数。 解答 这棵树非终端结点个数为2011−116=18952011-116=18952011−116=1895个。注意到对于每一个非终端结点，其最右孩子的右兄弟指针为空（因为已经没有其他兄弟了）。但还需要注意不要漏掉了根节点，因此有1895+1=18961895+1=189618...
二叉树习题
01-16
二叉树有五个性质，包括满二叉树、完全二叉树的概念，以及关于叶子结点、度为1的结点和度为2的结点之间的关系。 二叉树的存储方式主要有两种：顺序存储和链式存储。二叉链表存储是最常见的方法，每个结点包含两个...
二叉树模板代码 二叉树习题
03-20
2. 删除操作：删除一个节点时要考虑其子节点情况，可能需要调整树的结构以保持二叉树的性质。 3. 查找操作：在二叉树中查找特定值的节点，可以采用递归或迭代的方式。 4. 遍历操作：主要有前序遍历（根-左-右）、...
二叉树面试题
08-28
以下是一些关于二叉树的常见面试题及解题思路： 1. **定义与基本术语**： - 二叉树是每个节点最多有两个子节点的树结构，通常分为左子节点和右子节点。 - 节点包含一个值，可能有零个、一个或两个子节点。 - ...
第六章 树和二叉树习题1
03-20
本题涉及的知识点广泛，包括二叉树的基本性质、存储结构、形态多样性、完全二叉树以及相关计算。 1. 在二叉树的二叉链表存储结构中，每个节点有两个指针域，分别指向左子树和右子树。因此，如果有n个节点，会有n-1...
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
7-2 交换二叉树中每个结点的左孩子和右孩子
qq_63133157的博客
10-25 899
输入二叉树的先序序列。提示：一棵二叉树的先序序列是一个字符串，若字符是‘#’,表示该二叉树是空树，否则该字符是相应结点的数据元素。
二叉树的基本操作
qq_39119930的博客
05-29 353
/* 定义DataType为char类型 */typedef char DataTypec;/* 二叉树的结点类型 */typedef struct BitNode{ DataTypec data; struct BitNode *lchild,*rchild;}BitNode,*BitTree;/* 初始化二叉树，即把树根指针置空 */void BinTreeInit(BitTree BT);/...
二叉树的操作集：（二叉树的定义，遍历）
qq_51825761的博客
07-26 515
//但是你怎么知道什么时候开始已经访问了该节点的右节点，此时返回的根节点是由左孩子进入的还是由右孩子。///或许你会认为右根节点只需要入栈一次，当访问右节点的时候，不需要出栈，只需要取栈顶元素，///然后访问右节点，而访问右节点需要由根节点进入右节点，所以还是需要两次根节点，///后序遍历由于是最后访问根节点，所以根节点需要两次入队，因为先访问左节点，//创建一棵二叉树；///进入的我们是不知道的，所以还是需要根节点两次入栈。voidBehTraver(BinTreeBT)//后序遍历。......
QT类学习系列（8）- QPushButton，QToolButton的区别
MatthewMao
01-10 7348
QPushButton与QToolButton的区别 - weixin_42073232的博客 - CSDN博客https://blog.csdn.net/weixin_42073232/article/details/84848142 QToolButton 类提供了一个快速访问按钮的命令或选项, 通常在 qtoolbar 中使用。有个关联action，还可以设置快捷键； QToolBu...
push 函数介绍
poptar的博客
10-27 1万+
stack::push();//在栈顶增加元素 queue::push();//将x 接到队列的末端。 stack与queue常见方法介绍 1、stack stack 模板类的定义在<stack>头文件中。 stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。 定义stack 对象的示例代码如下： stack<int> s1; stack<string> s2..
linux push 汇编,在Linux中at&t程序集中’push’和’pushq’之间的区别是什么
weixin_42525189的博客
05-18 1187
我最近开始寻求更好地理解我的计算机是如何工作的.我的问题是关于push和pushq之间的区别.我知道push会将一个值写入堆栈,我的假设是pushq做了类似的事情. q在那里的事实让我觉得应该有一个微妙的区别,但我似乎无法理解差异.我说在使用命令’layout asm’使用gdb调试文件/ lib / udev / iphone-set-info时考虑这个问题.有问题的代码是：pushq $0x...
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 572
【代码】c语言（7.23）
python二叉树题
05-31
好的，这是一个关于二叉树的 Python 题目： 请实现一个函数，判断给定的二叉树是否为对称二叉树。 例如，下面这个二叉树是对称的： ``` 1 / \ 2 2 / \ / \ 3 4 4 3 ``` 但下面这个二叉树不是对称的： ``` 1 / \ 2 2 \ \ 3 3 ``` 函数的定义如下： ```python def isSymmetric(root: TreeNode) -> bool: pass ``` 其中 `TreeNode` 的定义如下： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right ``` 函数的返回值为 `True` 表示二叉树是对称的，返回值为 `False` 表示不是对称的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值