二叉树【2.5】代码专项

news2024/9/22 13:34:46

目录

醍醐灌顶——node* root 和node* &root作为参数的区别

return value：

 写一个前序遍历的（使用指针）

中序遍历，只改动了preorder，只调换了一行

 后序

层序（使用bfs），新建队列和vector

二叉树的层数

输出所有二叉树节点的层号

翻转二叉树，并且输出反转后的先序&中序序列​编辑

注意，此处向上，难度评级都是：简单！！！！！！！！>-<

还原二叉树

醍醐灌顶——node* root 和node* &root作为参数的区别

插入节点时有引用，而搜索时只有指针没有引用

先中后序遍历亦然，因为只是遍历或者修改节点data，不用引用，

新建节点、改变树的结构需要引用

return value：

3221225477 (0xC0000005): 访问越界，一般是读或写了野指针指向的内存。

3221225725 (0xC00000FD): 堆栈溢出，一般是无穷递归造成的。

 return value 3221225725

3221225620 (0xC0000094): 除0错误，一般发生在整型数据除了0的时候。

我说为何报错说是野指针了，因为没有new申请空间

 写一个前序遍历的（使用指针）

写半天写不对，才发现，自己构造节点可以输出正确的序列（中序亦然）

所以是节点的读入有问题

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];

void preorder(node* root)
{//递归边界：NULL
if(root == NULL)
return;
//遍历
printf("%d ",root->id ); 
preorder(root->lchild);
preorder(root->rchild);
  
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
//	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
//	for(int i=0;i<n;i++)
//	{
//		int l,r;
//		scanf("%d %d",&l,&r);
//			tree[i]=newnode(i);
//		if(!flag && (l!=-1||r!=-1))
//		{
//			flag=1;
//			root=tree[i];
//			//root->id=i;
//		}
//			if(l!=-1)tree[l]=newnode(l),tree[i]->lchild=tree[l];
//			if(r!=-1)tree[r]=newnode(r),tree[i]->rchild=tree[r];
//	}
//	int i=0;
node* n0=newnode(0);
node* n1=newnode(1);
node* n2=newnode(2);
node* n3=newnode(3);
node* n4=newnode(4);
node* n5=newnode(5);
n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;


//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
	
preorder(n0);	
}

 后来我发现了问题，你是边写变创建节点的，可能4一开始被你连上2，但是后来又被你新建new，2-》lchild还是4，但4的孩子在别的地址了，因为new又申请了别的空间

所以我一开始就把n个节点统统创建好？

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];

void preorder(node* root)
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
printf("%d ",root->id ); 
preorder(root->lchild);
preorder(root->rchild);
  
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}
//	int i=0;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=2;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=5;
//	cout<<"node="<<tree[i]->id<<"rchild="<<tree[i]->rchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//cout<<tree[0]->rchild->rchild->id;




	
preorder(root);	
}


//node* n0=newnode(0);
//node* n1=newnode(1);
//node* n2=newnode(2);
//node* n3=newnode(3);
//node* n4=newnode(4);
//node* n5=newnode(5);
//n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;

 答案对了但格式错误，因为末尾不能有多余的空格

所以新建一个vector存储他们吧

ac了（）

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}
//	int i=0;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=2;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=5;
//	cout<<"node="<<tree[i]->id<<"rchild="<<tree[i]->rchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//cout<<tree[0]->rchild->rchild->id;




	
preorder(root);	
for(int i=0;i<ans.size();i++)
{printf("%d",ans[i]);
if(i<ans.size()-1) printf(" ");
}
}


//node* n0=newnode(0);
//node* n1=newnode(1);
//node* n2=newnode(2);
//node* n3=newnode(3);
//node* n4=newnode(4);
//node* n5=newnode(5);
//n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;

中序遍历，只改动了preorder，只调换了一行

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
preorder(root->lchild);
ans.push_back(root->id) ;
preorder(root->rchild);
  
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}


	
preorder(root);	
for(int i=0;i<ans.size();i++)
{printf("%d",ans[i]);
if(i<ans.size()-1) printf(" ");
}
}

 后序

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
preorder(root->lchild);

preorder(root->rchild);
  ans.push_back(root->id) ;
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}


	
preorder(root);	
for(int i=0;i<ans.size();i++)
{printf("%d",ans[i]);
if(i<ans.size()-1) printf(" ");
}
}

层序（使用bfs），新建队列和vector

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
queue<node*> q;
void layorder(node *root)
{
	q.push(root);
	while(!q.empty())
	{
		//ans.push_back(->id);
		node* temp=q.front();
		ans.push_back(temp->id);
		q.pop();
		if(temp->lchild!=NULL) q.push(temp->lchild);
		if(temp->rchild!=NULL) q.push(temp->rchild);
		
	}
	
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}
//	int i=0;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=2;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=5;
//	cout<<"node="<<tree[i]->id<<"rchild="<<tree[i]->rchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//cout<<tree[0]->rchild->rchild->id;




	
layorder(root);	
for(int i=0;i<ans.size();i++)
{printf("%d",ans[i]);
if(i<ans.size()-1) printf(" ");
}
}


//node* n0=newnode(0);
//node* n1=newnode(1);
//node* n2=newnode(2);
//node* n3=newnode(3);
//node* n4=newnode(4);
//node* n5=newnode(5);
//n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;

二叉树的层数

我：在层序的基础上，添加layer计数，广度遍历完，答案就出来了

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;int lay;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
queue<node*> q;
int ans_layer=1;
void layorder(node *root)
{
	q.push(root);
	while(!q.empty())
	{
		//ans.push_back(->id);
		node* temp=q.front();
		ans.push_back(temp->id);
		q.pop();
		if(temp->lchild!=NULL) temp->lchild->lay=temp->lay+1,q.push(temp->lchild), ans_layer=temp->lay+1;
		if(temp->rchild!=NULL) temp->rchild->lay=temp->lay+1,q.push(temp->rchild), ans_layer=temp->lay+1;
		
	}
	
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}
//	int i=0;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=2;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=5;
//	cout<<"node="<<tree[i]->id<<"rchild="<<tree[i]->rchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//cout<<tree[0]->rchild->rchild->id;




root->lay =1;	
layorder(root);	
//for(int i=0;i<ans.size();i++)
//{printf("%d",ans[i]);
//if(i<ans.size()-1) printf(" ");
//}
printf("%d",ans_layer);
}


//node* n0=newnode(0);
//node* n1=newnode(1);
//node* n2=newnode(2);
//node* n3=newnode(3);
//node* n4=newnode(4);
//node* n5=newnode(5);
//n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;

答案：递归求解

height=max（left 子树height，right子树height）+1 

输出所有二叉树节点的层号

因为我刚才已经算出来了，只需输出即可

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;int lay;
};
node* tree[N];
vector<int> ans;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
queue<node*> q;
int ans_layer=1;
void layorder(node *root)
{
	q.push(root);
	while(!q.empty())
	{
		//ans.push_back(->id);
		node* temp=q.front();
		ans.push_back(temp->id);
		q.pop();
		if(temp->lchild!=NULL) temp->lchild->lay=temp->lay+1,q.push(temp->lchild), ans_layer=temp->lay+1;
		if(temp->rchild!=NULL) temp->rchild->lay=temp->lay+1,q.push(temp->rchild), ans_layer=temp->lay+1;
		
	}
	
}
node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}
//	int i=0;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=2;
//	cout<<"node="<<tree[i]->id<<"lchild="<<tree[i]->lchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//	 i=5;
//	cout<<"node="<<tree[i]->id<<"rchild="<<tree[i]->rchild->id<<"rchild="<<tree[i]->rchild->id<<endl;
//cout<<tree[0]->rchild->rchild->id;




root->lay =1;	
layorder(root);	
//for(int i=0;i<ans.size();i++)
//{printf("%d",ans[i]);
//if(i<ans.size()-1) printf(" ");
//}
for(int i=0;i<n-1;i++)
printf("%d ",tree[i]->lay );
printf("%d",tree[n-1]->lay );

}


//node* n0=newnode(0);
//node* n1=newnode(1);
//node* n2=newnode(2);
//node* n3=newnode(3);
//node* n4=newnode(4);
//node* n5=newnode(5);
//n0->lchild=n2;n0->rchild=n5;n5->rchild=n3;n2->lchild=n1;n2->rchild=n4;

翻转二叉树，并且输出反转后的先序&中序序列

我：翻转函数写了半天，其实就是递归的将所有节点的左孩子与有孩子对调

并且递归顺序与执行顺序无关

即

void rvs(node* &root)
{
	if(root==NULL) return;
	node* tp=new node;
	tp=root->lchild;
	root->lchild =root->rchild;
	root->rchild =tp;

	rvs(root->lchild);
	rvs(root->rchild);
	}

和

void rvs(node* &root)
{
	if(root==NULL) return;
	node* tp=new node;

	rvs(root->lchild);
	rvs(root->rchild);

	tp=root->lchild;
	root->lchild =root->rchild;
	root->rchild =tp;

	}

 都能ac

附完整代码

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;int lay;
};
node* tree[N];
vector<int> ans1,ans2;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans1.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
void midorder(node* root)//中序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
midorder(root->lchild);
ans2.push_back(root->id) ;
midorder(root->rchild);
  
}

void rvs(node* &root)
{
	if(root==NULL) return;
	node* tp=new node;
	tp=root->lchild;
	root->lchild =root->rchild;
	root->rchild =tp;

	rvs(root->lchild);
	rvs(root->rchild);
	}

node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}




root->lay =1;	
rvs(root);
preorder(root);	
for(int i=0;i<ans1.size();i++)
{printf("%d",ans1[i]);
if(i<ans1.size()-1) printf(" ");
}
printf("\n");
midorder(root);	
for(int i=0;i<ans2.size();i++)
{printf("%d",ans2[i]);
if(i<ans2.size()-1) printf(" ");
}
//for(int i=0;i<n-1;i++)
//printf("%d ",tree[i]->lay );
//printf("%d ",tree[n-1]->lay );

}

 答案的思路也是一样，但是用的静态数

并且使用swap进行交换。

试了，指针也可以swap

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;
struct node
{node* lchild;node* rchild;int data;int id;int lay;
};
node* tree[N];
vector<int> ans1,ans2;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans1.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
void midorder(node* root)//中序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
midorder(root->lchild);
ans2.push_back(root->id) ;
midorder(root->rchild);
  
}

void rvs(node* &root)
{
	if(root==NULL) return;
	node* tp=new node;
swap(root->lchild ,root->rchild );

	rvs(root->lchild);
	rvs(root->rchild);
	}

node* newnode(int id1)
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}
int main()
{int n;
	scanf("%d",&n);
	node* root=NULL;
	bool flag=0;
	for(int i=0;i<n;i++) tree[i]=newnode(i);
	for(int i=0;i<n;i++)
	{
		int l,r;
		scanf("%d %d",&l,&r);
			//tree[i]=newnode(i);
		if(!flag && (l!=-1||r!=-1))
		{
			flag=1;
			root=tree[i];
			//root->id=i;
		}
			if(l!=-1)//tree[l]=newnode(l),
			tree[i]->lchild=tree[l];
			if(r!=-1)//tree[r]=newnode(r),
			tree[i]->rchild=tree[r];
	}




root->lay =1;	
rvs(root);
preorder(root);	
for(int i=0;i<ans1.size();i++)
{printf("%d",ans1[i]);
if(i<ans1.size()-1) printf(" ");
}
printf("\n");
midorder(root);	
for(int i=0;i<ans2.size();i++)
{printf("%d",ans2[i]);
if(i<ans2.size()-1) printf(" ");
}
//for(int i=0;i<n-1;i++)
//printf("%d ",tree[i]->lay );
//printf("%d ",tree[n-1]->lay );

}

标程

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 50;
struct Node {
    int l, r;
} nodes[MAXN];
vector<int> pre, in, post;
void preOrder(int root) {
    if (root == -1) {
        return;
    }
    pre.push_back(root);
    preOrder(nodes[root].l);
    preOrder(nodes[root].r);
}
void inOrder(int root) {
    if (root == -1) {
        return;
    }
    inOrder(nodes[root].l);
    in.push_back(root);
    inOrder(nodes[root].r);
}
void revert(int root) {
    if (root == -1) {
        return;
    }
    revert(nodes[root].l);
    revert(nodes[root].r);
    swap(nodes[root].l, nodes[root].r);
}
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d%d", &nodes[i].l, &nodes[i].r);
    }
    revert(0);
    preOrder(0);
    inOrder(0);
    for (int i = 0; i < (int)pre.size(); i++) {
        printf("%d", pre[i]);
        if (i < (int)pre.size() - 1) {
            printf(" ");
        }
    }
    printf("\n");
    for (int i = 0; i < (int)in.size(); i++) {
        printf("%d", in[i]);
        if (i < (int)in.size() - 1) {
            printf(" ");
        }
    }
    return 0;
}

注意，此处向上，难度评级都是：简单！！！！！！！！>-<

还原二叉树

先序中序=》后序

这玩意必须递归写，

核心就是：给你两个区间，你返回根节点，最后自下而上构成一棵树，最终的返回值是最上面的根节点

#include<stdio.h>
#include<bits/stdc++.h>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1005;int n;int s1[N],s2[N];
struct node
{node* lchild;node* rchild;int data;int id;int lay;
};
node* tree[N];
vector<int> ans1,ans2,ans3;
void preorder(node* root)//前序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
ans1.push_back(root->id) ;
preorder(root->lchild);
preorder(root->rchild);
  
}
void midorder(node* root)//中序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
midorder(root->lchild);
ans2.push_back(root->id) ;
midorder(root->rchild);
  
}
void nxtorder(node* root)//后序遍历 
{//递归边界：NULL
if(root == NULL)
{//printf("=null");
return;

}

//遍历
//printf("%d ",root->id ); 
nxtorder(root->lchild);
nxtorder(root->rchild);
ans3.push_back(root->id) ;
  
}
node* newnode(int id1)//新建节点 
{
	node* Node=new node;
	Node->id =id1;
	Node->lchild=NULL;
	Node->rchild=NULL;
	return Node;
}

node* create(int a1,int b1,int a2,int b2)//前序的左右端点，中序的左右端点，返回值是根节点 
{
	if(a1>b1 ||a2>b2) return NULL;//注意return NULL，表示自己就是空节点，且不再递归 
	node* root=newnode(s1[a1]);
	int k;
	for(int i=0;i<n;i++)
	{	if(s2[a2+i]==s1[a1]){k=i;break;	}	}
	
	
	root->lchild =create(a1+1,a1+k,a2,a2+k-1);
	root->rchild =create(a1+k+1,b1,a2+k+1,b2);
	return root; 
}
int main()
{
	scanf("%d",&n);
	node* root=new node;
	for(int i=0;i<n;i++)	{scanf("%d",&s1[i]);	 } 
	for(int i=0;i<n;i++)	{scanf("%d",&s2[i]);	 } 



root=create(0,n-1,0,n-1);
//preorder(root);	//输出前序 
//for(int i=0;i<ans1.size();i++)
//{printf("%d",ans1[i]);
//if(i<ans1.size()-1) printf(" ");
//}
//printf("\n");
//midorder(root);	//输出中序
//for(int i=0;i<ans2.size();i++)
//{printf("%d",ans2[i]);
//if(i<ans2.size()-1) printf(" ");
//}
nxtorder(root);	//输出后序
for(int i=0;i<ans3.size();i++)
{printf("%d",ans3[i]);
if(i<ans3.size()-1) printf(" ");
}
//for(int i=0;i<n-1;i++)
//printf("%d ",tree[i]->lay );
//printf("%d ",tree[n-1]->lay );

}

解析

 后序中序还原，照搬会堆栈溢出，具体明天再说

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2071858.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

如何保证支付服务和交易服务订单状态一致？

如何保证支付服务和交易服务订单状态一致？

消息传给消费者&#xff0c;消费者自己弄丢 业务幂等 所有的业务都应该保证幂等性&#xff0c; 如何保障业务幂等性 非幂等业务表单重复提交&#xff0c;在进入表单之前生成唯一标识&#xff0c;未token&#xff0c;携带token进行请求&#xff0c;执行表单提交&#xff0c;把…
阅读更多...
unoredered_mapunordered_set封装

unoredered_mapunordered_set封装

各层封装关系 封装时细节/tips Rfr Ptr用来constiterator //HTIterator 模板 template<class K, class T, class Ptr, class Rfr, class KeyOfT, class Hash> class HTIterator//普通Iterator类 & const_iterator类 typedef HTIterator<K, T, T*, T&, KeyOfT…
阅读更多...
芯片中的电源VDD和地VSS

芯片中的电源VDD和地VSS

一、原理图中的电源和地符号 在绘制原理图的时候您应该会发现某个芯片上有VBAT VDD VSS VDDA VSSA那么他们都是什么意思呢&#xff0c;分别代表什么&#xff1f; 二、与常说的VCC的区别 可以看到VSS是表示GND 数字和模拟是分开的默认是数字&#xff0c;VDD表示电源&#xff0c;…
阅读更多...
DC-DC开关电源稳压电路设计——7- 40V转换5V和3.3V

DC-DC开关电源稳压电路设计——7- 40V转换5V和3.3V

本篇文章记录分享DC-DC开关电源稳压&#xff08;7-40V转换5V和3.3V&#xff09;电路设计的思路及原理图。 目录 一、电路稳压原理图 二、开关稳压芯片 1、BUCK降压电路 2.LM2596 &#xff08;1&#xff09;、LM2596简介 &#xff08;2&#xff09;、LM2596原理 1. 基…
阅读更多...
Python计算机视觉 第3章-图像到图像的映射

Python计算机视觉 第3章-图像到图像的映射

Python计算机视觉 第3章-图像到图像的映射 3.1　单应性变换 单应性变换&#xff08;Homography&#xff09;是计算机视觉中非常重要的一种几何变换&#xff0c;它用于将一个平面内的点映射到另一个平面内。具体来说&#xff0c;单应性变换可以描述一个图像在摄像机视角变化、…
阅读更多...
音视频封装格式之FLV

音视频封装格式之FLV

FLV&#xff08;Flash Video&#xff09;是一种常见的视频文件格式&#xff0c;FLV 格式最初是由 Adobe 公司开发的&#xff0c;旨在为网络视频提供一种高效、可扩展且易于流式传输的解决方案。随着在线视频的迅速发展&#xff0c;FLV 因其良好的兼容性和流式传输性能&#xff…
阅读更多...
4.2较难的栈和队列OJ

4.2较难的栈和队列OJ

本篇博客来手撕三道稍有难度的栈和队列相关OJ&#xff0c;题目均已插入超链接&#xff0c;点击即可跳转~ 一、设计循环队列 1、题目描述 设计你的循环队列实现。 循环队列是一种线性数据结构&#xff0c;其操作表现基于 FIFO&#xff08;先进先出&#xff0c;即first in fir…
阅读更多...
day39.动态规划+MySQL数据库复习

day39.动态规划+MySQL数据库复习

一.动态规划: 198.打家劫舍 你是一个专业的小偷&#xff0c;计划偷窃沿街的房屋。每间房内都藏有一定的现金&#xff0c;影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统&#xff0c;如果两间相邻的房屋在同一晚上被小偷闯入&#xff0c;系统会自动报警。 给定…
阅读更多...
深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】 单 master多 master多 master 多 slave 异步复制多 master 多 slave 同步复制Dledger 本文仅是文章笔记&#xff0c;整理了原文章中重要的知识点、记录了个人的看法 文章来源&#xff1a;编程导航-鱼皮【yes哥深入浅出消息队列专栏】 Brok…
阅读更多...
LeetCode100.删除链表的倒数第 N 个结点

LeetCode100.删除链表的倒数第 N 个结点

1. 题目大意 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 2. 思路分析 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]我们可以先遍历一遍链表求出…
阅读更多...
Data Localization Software Architecture - SAAS Localization CyberWin Future

Data Localization Software Architecture - SAAS Localization CyberWin Future

一、Future Window Industry Application Cross-platform Architecture The cross-platform architecture of Future Window adopts Hybird (hybrid mode mobile application), which is a mobile application development model that combines the characteristics of native …
阅读更多...
golang学习笔记——grom连接mysql

golang学习笔记——grom连接mysql

GORM 指南 The fantastic ORM library for Golang aims to be developer friendly. Golang的ORM库旨在对开发人员友好。 特性 全功能 ORM关联 (Has One&#xff0c;Has Many&#xff0c;Belongs To&#xff0c;Many To Many&#xff0c;多态&#xff0c;单表继承)Create&…
阅读更多...
【Redis】渐进式遍历和数据库管理

【Redis】渐进式遍历和数据库管理

渐进式遍历和数据库管理 渐进式遍历scan 数据库管理切换数据库清除数据库 渐进式遍历 Redis 使⽤ scan 命令进⾏渐进式遍历键&#xff0c;进⽽解决直接使⽤ keys 获取键时可能出现的阻塞问题。每次 scan 命令的时间复杂度是 O(1)&#xff0c;但是要完整地完成所有键的遍历&…
阅读更多...
数学建模笔记（三）：拟合算法

数学建模笔记（三）：拟合算法

前面介绍的插值方法&#xff0c;我们可以发现他的特点在于最终得到的曲线一定要经过已经给出的样本点的&#xff0c;而这次要介绍的拟合方法的区别在于&#xff0c;拟合不要求曲线一定要经过所有的样本点&#xff0c;只要这个曲线与样本点之间的误差足够小&#xff0c;距离足够…
阅读更多...
unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

一、什么是AssetBundle&#xff1f; 定义AssetBundle。 AssetBundle 是一个存档文件&#xff0c;包含可在运行时由 Unity 加载的特定于平台的非代码资源&#xff08;比如模型、纹理、预制件、音频剪辑甚至整个场景&#xff09;。AssetBundle 可以表示彼此之间的依赖关系&…
阅读更多...
PD取电快充协议方案

PD取电快充协议方案

PD快充协议是通过调整电压和电流来提供不同的充电功率。它采用了一种基于USB-C端口的通信协议&#xff0c;实现了充电器于设备之间的信息交换。在充电过程中设备会向充电器发出请求&#xff0c;要求提供不同的电压和电流&#xff0c;充电器接收到请求后&#xff0c;会根据设备的…
阅读更多...
数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

一、未来之窗行业应用跨平台架构 未来之窗跨平台架构采用Hybird&#xff08;混合模式移动应用&#xff09;是一种结合了原生应用&#xff08;Native App&#xff09;和网页应用&#xff08;Web App&#xff09;特点的移动应用开发模式。 二、特点 2.1. 开发成本相对较低 - 与…
阅读更多...
C++码表之Unicode

C++码表之Unicode

今日诗词&#xff1a; 折花逢驿使&#xff0c;寄与陇头人。 江南无所有&#xff0c;聊赠一枝春。 ——《赠范晔诗》【南北朝】陆凯 引言&#xff1a; 上一期我们说到了ASCII码表&#xff0c;这是一种现如今不是那么通用的机制&#xff0c;随着计算机的普及&#xff0c;越来越…
阅读更多...
电脑ip地址为什么会自己变更？电脑ip怎么改

电脑ip地址为什么会自己变更？电脑ip怎么改

在当今这个高度依赖互联网的时代&#xff0c;IP地址作为网络设备的身份标识&#xff0c;其稳定性和可管理性对于网络通信的顺畅至关重要。然而&#xff0c;许多用户可能会遇到电脑IP地址自动变更的情况&#xff0c;这不仅可能影响到网络连接的稳定性&#xff0c;还可能给远程访…
阅读更多...
怎么使用win10录屏快捷键 ？分享三款录屏工具

怎么使用win10录屏快捷键 ？分享三款录屏工具

录屏软件在我们日常生活中越来越常见&#xff0c;无论是做教程、记录游戏精彩瞬间还是进行远程教学&#xff0c;一个好的录屏软件都能让我们的生活变得更加便捷。不少人也会选怎win10自带的录屏&#xff0c;使用WIN10 录屏快捷键【winG】&#xff0c;就可以唤出录屏工具&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023