算法笔记9.2 二叉树的遍历 及 中序分别与先序、后序、层序搭配构建二叉树

最新推荐文章于 2024-07-23 18:31:57 发布
最新推荐文章于 2024-07-23 18:31:57 发布
阅读量507 收藏 4
点赞数 1
分类专栏： 算法竞赛 算法笔记 数据结构 # 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hza419763578/article/details/89042656
版权

目录

9.2.1先序遍历

9.2.2 中序遍历

9.2.3后序遍历

9.2.4层序遍历

9.2.5根据先序中序序列，建立二叉树

        变式.根据后序中序序列还原二叉树

        变式:根据层序中序序列还原二叉树

9.2.6二叉树的静态实现

 

二叉树的遍历共四种:先序遍历、中序遍历、后序遍历、层次遍历
前三种：  采用深度优先搜索(DFS)实现   递归
层次遍历: 采用广度优先搜索(BFS)实现    队列

二叉树的递归定义和前三种遍历方式很好地融合了

一定记住:对于前三种遍历(先序，中序，后序)左子树一定先于右子
         树遍历，所谓的“先中后”指的是根结点root在遍历中的位置。
因此：
     先序遍历:根结点->左子树->右子树
     中序遍历:左子树->根结点->右子树
     后序遍历:左子树->右子树->根结点

     

 

9.2.1先序遍历

先序遍历的实现

9-7先序序列:ABDECF
先序遍历序列的第一个元素一定是根结点

//先根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问根结点root，如输出数据域
	cout<<root->data<<" ";
	//访问左子树
	preorder(root->lchild);
	//访问右子树
	preorder(root->rchild);
}

 

先序创建，因为心浮气躁，卡了好久，太艰难了。。。一定要冷静分析demo的代码

//创建树，先序插入  #表示结点为空
void CreateBiTree(node* &root)
{
    char c;
    cin>>c;
 
    if(c == '#')
        root = NULL;  //null表示为空枝
    else
    {
        root = new node;
        root->data = c;
        CreateBiTree(root->lchild);
        CreateBiTree(root->rchild);
    }
}

实例：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;

struct node{
	char data;//数据域  类型此处默认设为char
	node* lchild;//指向左子树根结点的指针
	node* rchild;//指向右子树根结点的指针	
};

//新建结点(插入结点时用)
//生成一个新结点，v为结点的权值
node* newNode(char v){
	node* Node=new node;//申请一个node型变量的地址空间
	Node->data=v;
	Node->lchild=Node->rchild=NULL;//初始状态下没有左右孩子
	return Node;
}

//先序插入遍历
void pre_Create(node* &root)
{
    char c;
    cin>>c;
 
    if(c == '#')
        root = NULL;  //null表示为空枝
    else
    {
        root = new node;
        root->data = c;
        pre_Create(root->lchild);
        pre_Create(root->rchild);
    }
}

//先根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问根结点root，如输出数据域
	cout<<root->data;
	//访问左子树
	preorder(root->lchild);
	//访问右子树
	preorder(root->rchild);
}

//层序遍历
void LayerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input1.txt","r",stdin);
	node* root;
	pre_Create(root);//先根插入 创建二叉树
	
	cout<<"先序遍历:";
	preorder(root);
	cout<<endl;

	cout<<"层序遍历:";
	LayerOrder(root);
	cout<<endl;

	return 0;
}

input1.txt

ABD##E##C#F##

运行结果：

 

9.2.2 中序遍历

左子树->根结点->右子树
只要知道根结点，就可以通过根结点在中序遍历序列中的位置区分出左子树和右子树
中序序列:DBEACF

中序遍历代码：

//中根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问左子树
	preorder(root->lchild);
	//访问根结点root，如输出数据域
	cout<<root->data;
	//访问右子树
	preorder(root->rchild);
}

样例：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;

struct node{
	char data;//数据域  类型此处默认设为char
	node* lchild;//指向左子树根结点的指针
	node* rchild;//指向右子树根结点的指针	
};

//新建结点(插入结点时用)
//生成一个新结点，v为结点的权值
node* newNode(char v){
	node* Node=new node;//申请一个node型变量的地址空间
	Node->data=v;
	Node->lchild=Node->rchild=NULL;//初始状态下没有左右孩子
	return Node;
}

//先序插入遍历
void pre_Create(node* &root){
    char c;
    cin>>c; 
    if(c == '#')
        root = NULL;  //null表示为空枝
    else{
        root = new node;
        root->data = c;
        pre_Create(root->lchild);
        pre_Create(root->rchild);
    }
}

//中根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问左子树
	preorder(root->lchild);
	//访问根结点root，如输出数据域
	cout<<root->data;
	//访问右子树
	preorder(root->rchild);
}

//层序遍历
void LayerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input1.txt","r",stdin);
	node* root;
	pre_Create(root);//先根插入 创建二叉树
	
	cout<<"中序遍历:";
	preorder(root);
	cout<<endl;

	cout<<"层序遍历:";
	LayerOrder(root);
	cout<<endl;

	return 0;
}

input1.txt

ABD##E##C#F##

运行结果：

 

 

9.2.3后序遍历

左子树->右子树->根结点
样例后序序列:DEBFCA
后序序列的最后一个结点一定是根结点
★:无论是先序遍历序列还是后序遍历序列都必须知道中序遍历序列才能唯一确定一颗树
   因为通过先序遍历序列和后序遍历序列都只能得到根结点，而只有通过中序遍历序列
   才能利用根结点把左右子树分开，从而递归生成一棵二叉树(需要所有元素互不相同时才能使用)

后序遍历：

//后根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问左子树
	preorder(root->lchild);
	//访问右子树
	preorder(root->rchild);
	//访问根结点root，如输出数据域
	cout<<root->data;
}

样例：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;

struct node{
	char data;//数据域  类型此处默认设为char
	node* lchild;//指向左子树根结点的指针
	node* rchild;//指向右子树根结点的指针	
};

//新建结点(插入结点时用)
//生成一个新结点，v为结点的权值
node* newNode(char v){
	node* Node=new node;//申请一个node型变量的地址空间
	Node->data=v;
	Node->lchild=Node->rchild=NULL;//初始状态下没有左右孩子
	return Node;
}

//先序插入遍历
void pre_Create(node* &root){
    char c;
    cin>>c; 
    if(c == '#')
        root = NULL;  //null表示为空枝
    else{
        root = new node;
        root->data = c;
        pre_Create(root->lchild);
        pre_Create(root->rchild);
    }
}

//后根遍历
void preorder(node* root){
	if(root==NULL) return;//到达空树，递归边界
	//访问左子树
	preorder(root->lchild);
	//访问右子树
	preorder(root->rchild);
	//访问根结点root，如输出数据域
	cout<<root->data;
}

//层序遍历
void LayerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input1.txt","r",stdin);
	node* root;
	pre_Create(root);//先根插入 创建二叉树
	
	cout<<"后序遍历:";
	preorder(root);
	cout<<endl;

	cout<<"层序遍历:";
	LayerOrder(root);
	cout<<endl;

	return 0;
}

input1.txt：

ABD##E##C#F##

运行结果：

 

9.2.4层序遍历

从上到下，从左到右 BFS
层序序列:ABCDEF

//层序遍历
void LayerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

上面每个样例都有层序输出

 

带层次的层序输出：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;

struct node{
	char data;//数据域  类型此处默认设为char
	int layer;//层次
	node* lchild;//指向左子树根结点的指针
	node* rchild;//指向右子树根结点的指针	
};

//新建结点(插入结点时用)
//生成一个新结点，v为结点的权值
node* newNode(char v){
	node* Node=new node;//申请一个node型变量的地址空间
	Node->data=v;
	Node->lchild=Node->rchild=NULL;//初始状态下没有左右孩子
	return Node;
}

//先序插入遍历
void pre_Create(node* &root){
    char c;
    cin>>c; 
    if(c == '#')
        root = NULL;  //null表示为空枝
    else{
        root = new node;
        root->data = c;
        pre_Create(root->lchild);
        pre_Create(root->rchild);
    }
}

//层序遍历
void LayerOrder(node* root){
	queue<node*> q;
	root->layer=1;//根的层次为1
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->layer<<":"<<top->data<<" ";
		if(top->lchild!=NULL){
			top->lchild->layer=top->layer+1;
			q.push(top->lchild);
		} 
		if(top->rchild!=NULL){
			top->rchild->layer=top->layer+1;
			q.push(top->rchild);
		}
	}
}

int main(){
	freopen("input1.txt","r",stdin);
	node* root;
	pre_Create(root);//先根插入 创建二叉树
	
	cout<<"层序遍历:";
	LayerOrder(root);
	cout<<endl;

	return 0;
}

运行结果：

 

9.2.5根据先序中序序列，建立二叉树

eg:
先:ABDECF
中:DBEACF

每次先序第一个提供根结点，中序根据根结点分割左右子树，
同样方式处理左右子树(先确定左右子树先后序列范围)如此反复

层序:ABCDEF

 

#include<iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef char Type;

Type pre[100],in[100];

struct node{
	Type data;
	node* lchild;
	node* rchild;	
};

node* newNode(Type x){
	node* Node=new node;
	Node->data=x;
	Node->lchild=Node->rchild=NULL;
	return Node;
}

//先序[preL,preR]  中序:[inL,inR]
node* Create(int preL,int preR,int inL,int inR){
	if(preL>preR) return NULL;//先序序列为空 结束
	node* root=newNode(pre[preL]);//根结点 先序第一个
	//中序中找到根结点位置以分割左右子树
	int k;
	for(k=inL;k<=inR;k++){
		if(in[k]==pre[preL]) break;//所有结点data互不相同 否则出bug
	}
	//找到k即为根结点在中序中的位置下标
	//分割左右子树
	int numLeft=k-inL;//左子树长度

	//递归求左右子树 
	//左子树先序中序序列范围  第一个pre是根结点
	root->lchild=Create(preL+1,preL+numLeft,inL,k-1);
	//右子树先序中序序列范围  k是中序根结点
	root->rchild=Create(preL+numLeft+1,preR,k+1,inR);

	return root;//返回根结点地址
}

//先序遍历
void preOrder(node* root){
	if(root==NULL) return;
	cout<<root->data;
	preOrder(root->lchild);
	preOrder(root->rchild);
}

//中序遍历
void inOrder(node* root){
	if(root==NULL) return;
	inOrder(root->lchild);
	cout<<root->data;
	inOrder(root->rchild);
}

//后序遍历
void postOrder(node* root){
	if(root==NULL) return;
	postOrder(root->lchild);
	postOrder(root->rchild);
	cout<<root->data;
}

//层序遍历
void layerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input5.txt","r",stdin);
	cin>>pre>>in;
	int preL,preR,inL,inR;
	preL=0,preR=strlen(pre)-1,inL=0,inR=strlen(in)-1;
	// cout<<preL<<" "<<preR<<" "<<inL<<" "<<inR<<endl;
	node* root=Create(preL,preR,inL,inR);
	cout<<"先序遍历:";preOrder(root);cout<<endl;
	cout<<"中序遍历:";inOrder(root);cout<<endl;
	cout<<"后序遍历:";postOrder(root);cout<<endl;
	cout<<"层序遍历:";layerOrder(root);cout<<endl;
	return 0;
}

input5.txt

ABDECF
DBEACF

//现在不要死扣太多，到时候系统地复习数据结构时就全懂了，而且很快！

 

变式.根据后序中序序列还原二叉树

#include<iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef char Type;

Type post[100],in[100];

struct node{
	Type data;
	node* lchild;
	node* rchild;	
};

//后序[postL,postR]  中序:[inL,inR]
node* Create(int postL,int postR,int inL,int inR){
	if(postL>postR) return NULL;//后序序列为空 结束
	node* root=new node;//根结点   new node不能少 否则就只是分配一个野指针 无法使用->
	root->data=post[postR];//后序第一个
	//中序中找到根结点位置以分割左右子树
	int k;
	for(k=inL;k<=inR;k++){
		if(in[k]==post[postR]) break;//所有结点data互不相同 否则出bug
	}
	//找到k即为根结点在中序中的位置下标
	//分割左右子树
	int numLeft=k-inL;//左子树长度

	//递归求左右子树 
	//左子树先序中序序列范围  最后一个post序列是根结点
	root->lchild=Create(postL,postL+numLeft-1,inL,k-1);
	//右子树先序中序序列范围  k是中序根结点
	root->rchild=Create(postL+numLeft,postR-1,k+1,inR);

	return root;//返回根结点地址
}

//先序遍历
void preOrder(node* root){
	if(root==NULL) return;
	cout<<root->data;
	preOrder(root->lchild);
	preOrder(root->rchild);
}

//中序遍历
void inOrder(node* root){
	if(root==NULL) return;
	inOrder(root->lchild);
	cout<<root->data;
	inOrder(root->rchild);
}

//后序遍历
void postOrder(node* root){
	if(root==NULL) return;
	postOrder(root->lchild);
	postOrder(root->rchild);
	cout<<root->data;
}

//层序遍历
void layerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input5_1.txt","r",stdin);
	cin>>post>>in;
	int postL,postR,inL,inR;
	postL=0,postR=strlen(post)-1,inL=0,inR=strlen(in)-1;
	// cout<<postL<<" "<<postR<<" "<<inL<<" "<<inR<<endl;
	node* root=Create(postL,postR,inL,inR);
	cout<<"先序遍历:";preOrder(root);cout<<endl;
	cout<<"中序遍历:";inOrder(root);cout<<endl;
	cout<<"后序遍历:";postOrder(root);cout<<endl;
	cout<<"层序遍历:";layerOrder(root);cout<<endl;
	return 0;
}

input5_1.txt

DEBFCA
DBEACF

 

变式:根据层序中序序列还原二叉树

原理一样(层序第一个是根结点，还是提供根)，关键找到左右子树的层序和中序序列，此时由于下次左右子树的层序序列不是连续排列的，需要重新建立数组存储下来再传递（先序后序序列一定一样，不过元素顺序不同而已），仅此而已

#include<iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef char Type;

const int MAXN=100;

struct node{
	Type data;
	node* lchild;
	node* rchild;	
};

//后序[postL,postR]  中序:[inL,inR]
node* Create(Type layer[],Type in[],int len){//长度都一样 一个len即可
	if(len==0) return NULL;
	node* root=new node;
	root->data=layer[0];
	int k;
	//中序中找根
	for(k=0;k<len;k++){
		if(in[k]==layer[0]) break;
	}
	//new节省空间  申请左右子树的层序即可 中序可由指针加法移位获得
	Type *Llay=new Type[len],*Rlay=new Type[len];
	
	//左子树的先序序列  
	/*中序都很简单根两边就是  难找的就是这个先序 
	好在只是中序顺序换了下 根据中序在整个先序里找
	重复的即可，此处也可看出序列data不能有相同*/
	int cnt=0;
	for(int i=1;i<len;i++){//第0个根结点,i从1开始即可
		for(int j=0;j<k;j++){
			if(layer[i]==in[j]){//in[j]不是in[k] 别犯傻
				Llay[cnt++]=layer[i];
				break;//不可能有重复
			}
		}
	}
	root->lchild=Create(Llay,in,cnt);

	cnt=0;
	for(int i=1;i<len;i++){
		for(int j=k+1;j<len;j++){
			if(layer[i]==in[j]){//in[j]不是in[k] 别犯傻
				Rlay[cnt++]=layer[i];
				break;//不可能有重复
			}
		}
	}
	root->rchild=Create(Rlay,in+k+1,cnt);

	return root;//返回根结点地址
}

//先序遍历
void preOrder(node* root){
	if(root==NULL) return;
	cout<<root->data;
	preOrder(root->lchild);
	preOrder(root->rchild);
}

//中序遍历
void inOrder(node* root){
	if(root==NULL) return;
	inOrder(root->lchild);
	cout<<root->data;
	inOrder(root->rchild);
}

//后序遍历
void postOrder(node* root){
	if(root==NULL) return;
	postOrder(root->lchild);
	postOrder(root->rchild);
	cout<<root->data;
}

//层序遍历
void layerOrder(node* root){
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* top=q.front();
		q.pop();
		cout<<top->data;
		if(top->lchild!=NULL) q.push(top->lchild);
		if(top->rchild!=NULL) q.push(top->rchild);
	}
}

int main(){
	freopen("input5_2.txt","r",stdin);
	Type layer[MAXN],in[MAXN];
	cin>>layer>>in;
	int len=strlen(layer);
	cout<<len<<endl;
	node* root=Create(layer,in,len);
	cout<<"先序遍历:";preOrder(root);cout<<endl;
	cout<<"中序遍历:";inOrder(root);cout<<endl;
	cout<<"后序遍历:";postOrder(root);cout<<endl;
	cout<<"层序遍历:";layerOrder(root);cout<<endl;
	return 0;
}

input5_2.txt

ABCDEF
DBEACF

 

说明:中序序列可以与先序序列、后序序列、层序序列中的任意一个来构建唯一的二叉树，而后者两两搭配或是三个一起上都无法构建唯一的二叉树。原因是先序、后序、层序均是提供根结点，作用是相同的，都必须由中序序列来区分出左右子树。

 

9.2.6二叉树的静态实现

#include<iostream>
#include<queue>
using namespace std;

typedef int Type;
const int MAXN=100;
struct node{
	Type data;
	int lchild,rchild;
}Node[MAXN];

int index=0;
int newNode(int v){
	Node[index].data=v;
	Node[index].lchild=Node[index].rchild=-1;
	return index++;
}

void search(int root,int x,int newdata){
	if(root==-1) return;
	if(Node[root].data==x){
		Node[root].data=newdata;//不return 符合条件的都该
	}
	search(Node[root].lchild,x,newdata);
	search(Node[root].rchild,x,newdata);
}

void insert(int &root,int x){
	if(root==-1){//注意
		root=newNode(x);//改root指向的那块内存
		return;
	}
	//坑人地不给代码
	if(/*由二叉树的性质x应该插在左子树*/){
		insert(Node[root].lchild,x);
	}else{
		insert(Node[root].rchild,x);
	}
}

//坑人的建立，函数返回根结点root下标
int Create(int data[],int n){
	int root=-1;
	for(int i=0;i<n;i++){
		insert(root,data[i]);
	}
	return root;
}

//先序遍历
void preorder(int root){
	if(root==-1) return;
	cout<<Node[root].data;//非指针而是结构体变量直接用.
	preorder(Node[root].lchild);
	preorder(Node[root].rchild);
}

//中序遍历
void inorder(int root){
	if(root==-1) return;
	preorder(Node[root].lchild);
	cout<<Node[root].data;//非指针而是结构体变量直接用.
	preorder(Node[root].rchild);
}

//后序遍历
void postorder(int root){
	if(root==-1) return;
	preorder(Node[root].lchild);
	preorder(Node[root].rchild);
	cout<<Node[root].data;//非指针而是结构体变量直接用.
}

//层序遍历
void layerorder(int root){
	queue<int> q;
	q.push(root);
	while(!q.empty()){
		int top=q.front();
		q.pop();
		cout<<Node[top].data<<" ";
		if(Node[top].lchild!=-1) q.push(Node[top].lchild);
		if(Node[top].rchild!=-1) q.push(Node[top].rchild);
	}
}


int main(){
	/*不会test  实在不知道更具二叉树的什么性质应该插在左子树*/
	return 0;
}

 

奇迹是执着的人创造的
关注
专栏目录
与二叉树相关的算法题
Zha_yc的博客
01-10 250
1. 二叉树的遍历 1.1 思路 递归应该如何写？ 1、确定递归的参数和返回值 2、确定终止条件 3、确定单层递归逻辑 迭代应该如何写？ 前序遍历为例，应先将根节点入栈，进入循环，一次从栈中弹出一个节点，读出节点值，再将右子节点、左子节点分别入栈。直至节点栈为空 中序遍历和前序遍历的情况不一样，中序遍历访问节点和处理节点的顺序是不一致的，访问到父节点需要将其存入栈中，直到访问到最左边的节点才能开始处理节点。中序遍历的思路：每次先找到该节点的最左边的子孙节点，访问完子孙节点，开始出栈，处理节点
华为0830-题解-频率搬移值分配| 二叉树构建+层序遍历
2301_79125431的博客
09-06 205
中兴领军：二面美团：二面后人才库（就当寄了，“美团，卸载”）华为云：免笔试阿里控股：笔试依托，约了二面阿里淘天：笔试ak，等约面（快点吧）京东：笔试依托，hr打。公司：喜马拉雅 岗位：运营岗 状态：已经实习三个月工作内容：入职都在跟进同一个项目，当一个小帮手，文档，表格，ppt这些是日常实习少不了的。不知名小厂实习4个月，岗位是大数据的实施岗位。末流211本科意外被天美捞去群面，进去之后发现是9人还是10人一起面，其中不乏清华和新国立的大佬，也有美硕和英本英硕的大佬，其余基本都是985的硕士吧，且有着大。
建二叉树并分别用先先序、中序和后序遍历,然后输出各遍历序列
05-15
1、用二叉链表作为存储结构，建立一棵二叉树。 2、分别按先序、中序和后序遍历二叉树，输出各遍历序列。 3、编写交换二叉树中所有结点左右孩子
根据前序中序遍历建立二叉树
把握自己。
09-10 4117
根据前序中序遍历建立二叉树(2009-03-20 20:15:28)     【前言】     这个选题源自课上的一个习题，题目提供了二叉树的前序遍历和中序遍历，要求出整个二叉树。刚一做这道题时，还有些迷惑。但是，既然答案是确定的，就一定存在着算法，来求出这个二叉树。经过一些摸索，最终确定了求解算法。     【分析】     二叉树的遍历一共有四种方法，分
二叉树的建立和四种遍历办法（前序，中序，后序，层次遍历）
Hide on Bush的博客
01-30 363
#include<stdio.h> #include<stdlib.h> #include<iostream> #include<queue> using namespace std; typedef struct tree#二叉树的结构体 { char data; tree *left; tree *right; }tree; tree *c...
根据先序遍历和中序遍历建立二叉树
ccbka的博客
11-11 701
#include #include #include #include using namespace std; typedef struct node { char data; node* left; node* right; }node; void create_btree(node*& one_node,const char* pre,const char* in,in
根据中序遍历序列构造二叉树
weixin_44386939的博客
06-17 1779
最大二叉树 思路 最大元素为根,左右子树分别递归地构造。 代码 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val) * this.left = (left===undefined ? null : left) * this.right = (right===undefined ?
数据结构C++——二叉树和树
最新发布
qq_60987997的博客
07-23 1143
设完全二叉树中一元素的序号为i, 1≤i≤n。，存在两个不同的二叉树，经过中序遍历都能得到这个结果。但实际上，这两颗二叉树想要实际表达的算式并不相同。与我们希望得到的最为接近。(复制、删除、输出等)。：按照树的层级，从上到下、从左到右依次遍历。：可以看作是缺少了部分元素的完全二叉树。设二叉树中元素数目为n。（前缀和后缀表达式中不会存在歧义）的次序访问树中元素，在同一层中，比如：家庭关系、公司组织……在二叉树的遍历中，每个元素。得到的表达式分别称为其的。树(tree)t是一个。实现，层次遍历通常借助。
算法笔记（胡凡）学习笔记@Kaysen
Kaysen_Zhao的博客
08-12 2422
本文旨在记录算法笔记学习过程中的收获和一些知识点，部分易错知识点只针对个人而言，CCF-CSP考试冲鸭！！！ Chapter 2 C/C++快速入门（易错知识点） 2.1 基本数据类型 变量定义注意区分大小写。 一、整型 整型int，32bit（4Byte），取值范围是，绝对值在范围内的整数都可以定义成int。 长整型long long，64bit（8Byte），取值范围是，绝对值超过的整数就需要用long long存储。 ...
数据结构-PHP 平衡二叉树(AVL)
qq_38937634的博客
12-11 884
数据结构-PHP 平衡二叉树(AVL) 这篇文章主要介绍一下 平衡二叉树(AVL)，对于 二分搜索树 来说，如果树上的 元素 是顺序 添加的，会导致数据退化成一个 链表，这样就会造成很严重的性能问题，此时就需要在 二分搜索树 的基础上，保证元素插入时平衡，在了解 AVL 之前，需要您对 二分搜索树 有一定的了解，可以参考之前的文章。 1.二分搜索树的问题 如下图所示，若向二分搜索树中添加的元素是按照 顺序 从小到大依次插入的，这样会导致最后节点退化成链表: Tips：反过来依次从大到插入元素也会出现退化
中序遍历+后序/先序遍历构建二叉树
Bing's Blog
11-10 791
中序遍历+后序/先序遍历构建二叉树@(算法学习)给定中序+先序，中序+后序可以唯一构建一棵二叉树。给定先序+后序，无法唯一确定，但是却是很好的考点，问总共有多少种可能。。。如2016.9月份PAT最后一题就是考察这个知识点。#include <stdio.h> #include <stdlib.h>struct node { int data; struct node *left;
通过树的中序和先序遍历生成二叉树
Taylar_where的博客
05-19 816
关于二叉树的概念： 百度百科给的定义是： 二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。如果不考虑连通性，允许图中有多个连通分量，这样的结构叫做森林。 二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态： 图一 (1)...
根据中序遍历和后序遍历树构造二叉树
Loving you
01-24 7961
根据中序遍历和后序遍历树构造二叉树注意事项：可以假设树中不存在相同数值的节点
二叉树先序遍历中序遍历建立二叉树然后后序遍历
fanc的博客
01-23 680
题目描述 二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历 其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问 根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子 树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定 前序遍历与中序遍历能够唯一确定后序遍历）。 输入 两个
按中序顺序建立一棵二叉树
douxianer
11-14 2226
按中序顺序建立一棵二叉树 通过递归实现，递归的终止条件是当前节点是否为空。首先递归调用遍历左子树，然后访问当前节点，最后递归调用右子树。 #include <stdio.h> #include <stdlib.h> typedef char Elem; typedef struct BiTNode{ //创建结点结构体 Elem data; struct BiTNode *lchild,*rchild; //定义左孩子指针，右孩子指针 }BiTNode,*BiTre
关于中序创建二叉树
weixin_57940917的博客
11-14 7297
内容:编写程序，实现下述功能，并上机调试通过。 按中序顺序建立一课二叉树； 用非递归的方式遍历二叉树（先序，中序或后序），输出遍历序列 本题有两个要求，首先，要用中序顺序建立二叉树。但问题在于，只用中序输入无法创建一个确定的二叉树，因为对于一个已知的中序遍历结果，由于根节点不确定性，所以可能会对应多种不同结构的二叉树，例子如下: 所以我们要想办法解决根节点不确定的问题，对此有两个方向的想法。 一是：在编译过程规定好根节点的标识符，当输入该字符时，直接将该字符定义为根节点，在遍历结果中，该字符..
二叉树的构建与遍历（先序、中序、后序、层次）
热门推荐
人生处处是围城，一切都是最好的安排！
01-14 1万+
二叉树的构建与遍历
由前序遍历和中序遍历构建二叉树（C++语言）
CSDN 精品推荐
11-27 1895
设计思路： char* pre为前序遍历的顺序 char* in为中序遍历的顺序 首先建立一个指针p，用循环在in中找到根节点 left为左子树个数=p-in（指针差值） right为右子树个数（n-left-1） 之后递归调用该函数构建左右子树 代码： /** *作者：魏宝航 *2020年11月27日,下午15:50 */ #include<iostream> using namespace std; class Node { public: char ch; N
创建二叉树并中序遍历
Qianzshuo的博客
10-22 2884
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入有多组测试数据。 每组数据为一行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 Copy a#b#cdef##
二叉树遍历：先序、中序、后序与层序
"二叉树的遍历方法主要包括先序遍历、中序遍历、后序遍历和层序遍历。这些遍历方式是理解二叉树数据结构的关键，确保每个节点被访问一次且仅被访问一次。在创建二叉树时，通常采用先建左子树再建右子树的方式。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值