二叉树【2.5】代码专项

已于 2024-08-25 22:13:49 修改
阅读量1.4k 收藏 16
点赞数 34
文章标签： 数据结构
于 2024-08-25 00:17:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68339197/article/details/141502226
版权

目录

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

return value：

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

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

 后序

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

二叉树的层数

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

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

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

还原二叉树

先序中序=》后序

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

part1导入，构建结构体（指针形式）​编辑

part2后序中序=》生成一棵树，返回根节点

part3层序遍历bfs

part4 intmain​编辑 

层序中序还原

醍醐灌顶——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 );

}

解析

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

后序+中序-》前序

破案了，溢出是因为我的输入还是先序中序。。

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;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[b1]);
	int k;
	for(int i=0;i<n;i++)
	{	if(s2[a2+i]==s1[b1]){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);
	root->lchild =create(a1,a1+k-1,a2,a2+k-1);
	root->rchild =create(a1+k,b1-1,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 );

}

pat1020：后序中序=》层序

改个输出就行

附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;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,ans4;
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) ;
  
}
void layorder(node *root)//层序遍历 
{
	queue<node*> q;
	q.push(root);
	while(!q.empty())
	{
		//ans.push_back(->id);
		node* temp=q.front();
		ans4.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;
}

node* create(int a1,int b1,int a2,int b2)//后序的左右端点，中序的左右端点，返回值是根节点 
{
	if(a1>b1 ||a2>b2) return NULL;//注意return NULL，表示自己就是空节点，且不再递归 
	node* root=newnode(s1[b1]);
	int k;
	for(int i=0;i<n;i++)
	{	if(s2[a2+i]==s1[b1]){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);
	root->lchild =create(a1,a1+k-1,a2,a2+k-1);
	root->rchild =create(a1+k,b1-1,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 );
layorder(root);	//输出层序 
for(int i=0;i<ans4.size();i++)
{printf("%d",ans4[i]);
if(i<ans4.size()-1) printf(" ");
}
}

情深笔记模版

part1导入，构建结构体（指针形式）

part2后序中序=》生成一棵树，返回根节点

part3层序遍历bfs

part4 intmain 

拼起来就是完整的代码了 

层序中序还原

这样照搬刚刚的递归算法似乎不太现实，因为层序会破坏左右子树的连续性

我的思路

 剪枝：层序序列中当有人到达第3层时，其实无需再进行从头结点进行遍历与判断

所以需要写递归吗

晴·标程：

#include <cstdio>
#include <map>
#include <vector>
using namespace std;
const int MAXN = 50;
struct Node {
    int l, r;
} nodes[MAXN];
vector<int> pre, in, layer;
int buildTree(vector<int> layer, int inL, int inR) {
    if (layer.empty()) {
        return -1;
    }
    int root = layer[0];
    map<int, bool> isLeft;
    int inIndexOfRoot;
    for (int i = inL; i <= inR; i++) {
        if (in[i] == root) {
            inIndexOfRoot = i;
            break;
        } else {
            isLeft[in[i]] = true;
        }
    }
    vector<int> leftLayer, rightLayer;
    for (int i = 1; i < layer.size(); i++) {
        if (isLeft[layer[i]]) {
            leftLayer.push_back(layer[i]);
        } else {
            rightLayer.push_back(layer[i]);
        }
    }
    nodes[root].l = buildTree(leftLayer, inL, inIndexOfRoot - 1);
    nodes[root].r = buildTree(rightLayer, inIndexOfRoot + 1, inR);
    return root;
}
void preOrder(int root) {
    if (root == -1) {
        return;
    }
    pre.push_back(root);
    preOrder(nodes[root].l);
    preOrder(nodes[root].r);
}
int main() {
    int n, x;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        layer.push_back(x);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        in.push_back(x);
    }
    int root = buildTree(layer, 0, n - 1);
    preOrder(root);
    for (int i = 0; i < (int)pre.size(); i++) {
        printf("%d", pre[i]);
        if (i < (int)pre.size() - 1) {
            printf(" ");
        }
    }
    return 0;
}

实在是困难，某日填

爱喝热水的呀哈喽
关注
Java专项练习一（选择题）
MEIZE的博客
01-14 4596
1、在程序代码中写的注释太多，会使编译后的程序尺寸变大。错 解析：（注释是给人看的，只是为了方便程序员阅读理解代码，编译器不会读注释，只会读代码程序） 2、StringBuffer类对象创建之后可以再修改和变动。对 解析：（1.String对象不可变、StringBuffer对象可变的含义： 举个例子：String str = “aa”; str = “aa”+“bb”; 此时str的值为"aabb"，但是"aabb"不是在开始的字符串"aa"后面直接连接的"bb"，而是又新生成了字符串"aabb"，字符串
牛客网专项练习（九）
weixin_44077638的博客
03-20 991
二分查找的时间复杂度（ ） 正确答案: C O(N*log(N)) O(N) O(log(N)) O(N^2) 分析： 因为二分查找每次排除掉一半的不适合值，所以对于n个元素的情况： 一次二分剩下：n/2 两次二分剩下：n/2/2 = n/4 。。。 m次二分剩下：n/(2^m) 在最坏情况下是在排除到只剩下最后一个值之后得到结果，所以为 n/(2^m)=1; 2^m...
LeetCode专项练习之双堆（Two Heaps）笔记
qq_38250960的博客
04-18 644
本文是根据穷码农的LeetCode刷题建议而进行专项练习时记录的心得。 这次的题虽然只有三道，但都是Hard模式，花费了我很多时间。主要是自己以前从来没用过”堆“这个数据结构，导致自己需要相当一部分时间去从底层了解并实现它。做题时，自己也有很多思路没能想到，只能先参考大佬们的解题笔记。 不过，在自己了解了堆的特性后，觉得它理解起来并不困难，都是基于列表的一系列操作（优先队列）而实现的。这个...
算法学习 （门徒计划）4-3 专项面试题解析 学习笔记
ex_xyz的博客
07-31 1033
LeetCode 1367. 二叉树中的列表 LeetCode 958. 二叉树的完全性检验 LeetCode 剑指 Offer 36. 二叉搜索树与双向链表 LeetCode 464. 我能赢吗 LeetCode 172. 阶乘后的零 LeetCode 384. 打乱数组 LeetCode 437. 路径总和 III LeetCode 395. 至少有 K 个重复字符的最长子串 LeetCode 190. 颠倒二进制位 等。LeetCode 8.、380、402、316、1499、321
【答题有奖】25届非技术专项训练营——PT1.产品训练营
2301_79125431的博客
06-11 773
一句希望下周到岗，生怕错过这宝贵的机会，匆匆跨省来到北京，这个前一秒梦寐以求的大城市，等真正来到这里。一个衢州的金瑞泓做抛光工艺工程师，一个杭州的立昂微做PE，工资都差不多，包吃包住，家是衢州的。聊了聊项目，然后做了一道算法题（二叉树的前序遍历，递归和栈两种写法）栈的写法有些忘了，磨叽了一段时间。各位大佬们，刚高考完的女生推荐选什么专业，成绩超常发挥的话能过二本线，做好了大专然后专升本的准备，拜。1.等级差之内最大的组合求元组最大值，元组有[等级，价值]，求元组的最大价值，包含的元组的等级要求在。
【面经】2024春招-后端开发工程师1（3个问题，移动&TW等）
小哈里的博客
04-13 1755
【面经】2024春招-云计算后台研发工程师1（3个问题，移动&TW等） 文章目录 岗位与面经 基础1：数据库 & 网络（3个问题） 基础2：系统 & 语法 模板3：算法 & 项目（移动与TW） 场景：同时连着三场面试，八股复习不过来。 操作：每个知识点只总结最重要的3个面试题，记忆时建模，回答时适当引导深挖，然后把三个题回答好。 原理：本次的面经决定以缩减内容的方式进行迭代（上一次是扩充）
头歌上有关java作业
weixin_62075168的博客
11-08 7972
图中，在调用Iterator的next()方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next()方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next()方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext()方法返回false，表示到达了集合的末尾，终止对元素的遍历。，来获取集合的取出对象。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
[数据结构与算法基础] STL 介绍及相关练习
m0_65426912的博客
08-02 1041
STL，即标准模板库（Standard Template Library），是C++标准库中的一个重要组成部分。它提供了一组通用的类和函数模板，用于处理数据结构和算法。STL的主要目标是提高程序的可重用性、效率和可维护性。本文首先提供一些基础的练习题，方便了解STL的使用，以及常使用于什么类型的练习题中。说白了就是一个库，而我们常常会使用其中的一些容器，快速实现需求。使用STL解决此题，可以使用map，构造出map此题很简单，熟悉map相关操作即可。关于list的排序，使用。
2019秋招算法岗复盘 | 已收割腾讯、华为等offer
zero的博客
09-03 1096
点击上方“AI算法与图像处理”，选择加"星标"或“置顶”重磅干货，第一时间送达转载自：Mcrostrong一、背景介绍我这几天就要去公司入职了，岗位是人工智能工程师，曾参...
软件项目管理
m0_52248951的博客
06-13 4259
《基于案例的软件构造》学习笔记
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1188
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
C~排序算法
weixin_60461563的博客
09-27 1107
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 138
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1098
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
数据结构-4.2.串的定义和基本操作
最新发布
ADCvbV的博客
10-01 227
1.单/双引号不是字符串里的内容，他只是一个边界符，用来表示字符串的头和尾；2.空串也是字符串的子串，空串长度为0；3.字符的编号是从1开始，不是0；4.空格也是字符；
排序算法之归并排序
qq_64039411的博客
10-01 338
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
数据结构——初识树和二叉树
weixin_74209413的博客
09-26 1068
树是由根和子树组成，子树又是由子树的根和子树的子树组成，是一个递归的（嵌套的）结构。示意图如下：树的其他表现方式为何要重点研究每结点最多只有两个的树?二叉树的结构最简单，规律性最强;可以证明，所有树都能转为唯一对应的二又树，不失一般性。普通树(多又树)若不转化为二又树，则运算很难实现二叉树在树结构的应用中起着非常重要的作用，因为对二叉的许多操作算法简单，而任何树都可以与二叉树相互转换，这样就解决了树的存储结构及其运算中存在的复杂性。二叉树。
数据结构——二叉树的性质和存储结构
weixin_74209413的博客
09-28 803
初始条件：definition给出二叉树T的定义。操作结果:按definition构造二叉树T。初始条件:二叉树T存在。操作结果:先序遍历T，对每个结点访问一次。初始条件:二叉树T存在。操作结果:中序遍历T，对每个结点访问一次。初始条件:二叉树T存在。操作结果:后序遍历T，对每个结点访问一次。二叉树的性质和存储结构在二叉树的第i层最少有1个结点。深度为k的二叉树最少有k个结点。
平衡二叉树C语言实现与代码详解
总结来说，这段代码提供了一个基本的平衡二叉树数据结构及其操作，包括队列管理，这些是构建和维护平衡二叉搜索树必不可少的组成部分。要实现完整的平衡二叉树，还需要补充插入、删除和查找等核心操作的代码，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值