其他分享
首页 > 其他分享> > 第三次实验

第三次实验

作者:互联网


任意二叉树的层次遍历

题目描述

有若干个节点,每个节点上都有编号,把这些节点随意地构成二叉树,请编程输出该二叉树的层次遍历序列。

输入

第一行是n(n小于100),表示有n个节点,每个节点按从1到n依次编号。第一行后有n行,每行三个正整数i、l、r,分别表示节点i及对应的左右孩子的编号,如果不存在孩子则以-1表示。三个整数之间用一个空格隔开。

输出

输出该二叉数的层次遍历序列。

样例输入

4
1 2 4
3 1 -1
2 -1 -1
4 -1 -1

样例输出

3 1 2 4

#include<bits/stdc++.h>
using namespace std;
struct node
{
	int val;
	node *fa;
	node *l;
	node *r;
} BT[105];
queue<node *> s;//*别忘记 
void pre(node *T)//void别忘记 
{
	if(T==NULL)
	{
		return;
	}
	s.push(T);
	while(!s.empty())//while不要写成if
	{
		node *cur=s.front();
		cout<<cur->val<<" ";
		s.pop();//不要忘记pop;
		if(cur->l) s.push(cur->l);//cur->l不要写成T->l;是s.push()而不是pre() 
		if(cur->r) s.push(cur->r);
	}
}

int main()
{
	int n;
	cin>>n; 
	for(int i=1;i<=n;i++)
	{
		BT[i].val=i;
		BT[i].fa==NULL;
		BT[i].l==NULL;
		BT[i].r==NULL;
	}
	int a,b,c;
	for(int i=1;i<=n;i++)
	{
		cin>>a>>b>>c;
		if(b!=-1)
		{
			BT[a].l=BT+b;
			BT[b].fa=BT+a;
		}
		if(c!=-1)
		{
			BT[a].r=BT+c;
			BT[c].fa=BT+a;
		}
	}
	int pos;
	for(int i=1;i<=n;i++)
	{
		if(BT[i].fa==NULL)
		{
			pos=i;
			break; 
		}
	}
	pre(BT+pos);
}

小根堆的判定

题目描述

堆是以线性连续方式存储的完全二叉树,小根堆的每一个元素都不大于其左右孩子,现在给你n个完全二叉树数组存储序列,请编程判定相应完全二叉树数组存储序列是否为小根堆。

输入

第一行n(n<100),表示有n组测试用例。后边的n行,每一行都是相应完全二叉树数组存储序列(序列最长为100)。

输出

对应相应完全二叉树数组存储序列,判定为小根堆的输出True,否则输出False。

样例输入

2
30 26 27 88
5 6 7 8 9 10

样例输出

False
True

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	cin>>n;
	int PD[100];
	
	while(n--)
	{
		for(int i=1;i<100;i++)
		{
			PD[i]=99999;
		}
		bool flag=0;
		int t;
		for(int i=1;;i++)
		{
			cin>>PD[i];
			if(cin.get()=='\n')
			{
				t=i;
				break;	
			}
		}
		for(int j=1;j<=(t)/2;j++)
		{
			if(PD[j]>PD[2*j]||PD[j]>PD[2*j+1])
			{
				flag++;
			}
		}		
		if(flag) cout<<"False"<<endl;
		else cout<<"True"<<endl;
	}
}

最小堆的形成

题目描述

现在给你n个结点的完全二叉树数组存储序列,请编程调整为最小堆,并输出相应最小堆的存储序列。

输入

第一行是n,第二行是n个结点的完全二叉树数组存储序列。

输出

输出相应最小堆的存储序列。

样例输入

8
53 17 78 23 45 65 87 9

样例输出

9 17 65 23 45 78 87 53

#include<bits/stdc++.h>
using namespace std;
vector<int> a(100,10000); //数组a默认值为10000 
int main()
{
	int n;
	int t;
	cin>>n;
	int flag=1;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
	}
	while(flag!=0)
	{
		flag=0;
		for(int i=1;i<=n/2;i++)
		{
			if(a[2*i]<=a[2*i+1])
				t=2*i;
			else
				t=2*i+1;
	        if(a[i]>a[t])
			{ 
				flag++;
			  	int k=a[t];
			  	a[t]=a[i];
			  	a[i]=k;
			}
		}
	}
	for(int i=1;i<=n;i++)
	cout<<a[i]<<" ";	
}

无向图的深度优先搜索

题目描述

已知一个无向图G的顶点和边,顶点从0依次编号,现在需要深度优先搜索,访问任一邻接顶点时编号小的顶点优先,请编程输出图G的深度优先搜索序列。

输入

第一行是整数m和n(1<m,n<100),分别代表顶点数和边数。后边n行,每行2个数,分别表示一个边的两个顶点。

输出

该图从0号顶点开始的深度优先搜索序列。

样例输入

5 5
0 1
2 0
1 3
1 4
4 2

样例输出

0 1 3 4 2

#include<bits/stdc++.h>
using namespace std;
int a[100][100];
int vis[100];
int vertex[100];
int m,n;

void DFS(int v)
{
    cout<<vertex[v]<<" ";//输出顶点v
    vis[v]=1;//被访问过
    for(int j=0;j<m;j++)
        if(vis[j]==0&&a[v][j]==1)//没被访问过且存在边(v,j)
            DFS(j);
}

int main(){
	int x,y;
	cin>>m>>n;
	for(int i=0;i<m;i++){
		vertex[i]=i;
	}
	for(int i=0;i<n;i++){
		cin>>x>>y;
		a[x][y]=1;
		a[y][x]=1;
	}
	DFS(0);
}

无向图的广度优先搜索

题目描述

已知一个无向图G的顶点和边,顶点从0依次编号,现在需要广度优先搜索,访问任一邻接顶点时编号小的顶点优先,请编程输出图G的广度优先搜索序列。

输入

第一行是整数m和n(1<m,n<100),分别代表顶点数和边数。后边n行,每行2个数,分别表示一个边的两个顶点。

输出

该图从0号顶点开始的广度优先搜索序列。

样例输入

5 5
0 1
2 0
1 3
1 4
4 2

样例输出

0 1 2 3 4

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int m,n,x,y;
	int dian[100];
	int bian[100][100];
	int bs[100];
	cin>>m>>n;
	for(int i=0;i<m;i++)
	{
		dian[i]=i;
		bs[i]=1;
	}
	for(int j=0;j<n;j++)
	{
		cin>>x>>y;
		bian[x][y]=1;
		bian[y][x]=1;	
	}
	queue<int> s;
	s.push(0);
	bs[0]=0;
	while(!s.empty())
	{
		int cur=s.front();
		cout<<cur<<" ";
		for(int i=0;i<m;i++)
		{
			if(bs[i]&&bian[cur][i])
			{
				s.push(i);
				bs[i]=0;
			}
		}
		s.pop();
	}
}

最小生成树

题目描述

已知一个无向图G的顶点和边,顶点从0依次编号,请编程输出图G的最小生成树对应的边权之和。

输入

第一行是整数m和n(1<m,n<100),分别代表顶点数和边数。后边n行,每行3个数,分别表示一个边的两个顶点和该边的权值。

输出

最小生成树对应的边权之和。

样例输入

4 5
0 1 6
0 2 9
2 1 12
1 3 10
3 2 3

样例输出

18

#include <bits/stdc++.h>
using namespace std;
const int MAXV = 1000;
const int INF = 0x3fffffff;
int G[MAXV][MAXV];
int n;
bool vis[MAXV];
int d[MAXV];
int prim() {
	for(int i=0;i<1000;i++) d[i]=INF;
	d[0] = 0;
	int ans = 0;
	for (int i = 0; i < n;i++) {
		int u = -1, min = INF;
		for (int j = 0; j < n;j++) {
			if(vis[j] == false && d[j] < min) {
				u = j;
				min = d[j];
			}
		}
		if(u == -1) return -1;
		vis[u] = true;
		ans += d[u];
		for (int v = 0; v < n; v++) {
			if(vis[v] == false && G[u][v] != INF && G[u][v] < d[v]) d[v] = G[u][v];
		}
	}
	return ans;
}
int main() {
	int m, u, v, w;
	cin>>n>>m;
	for (int i = 0; i < n; i++) {
		for (int j =0; j < n; j++) {
			if (i == j) {
				G[i][j] = 0;
			} else {
				G[i][j] = 999999;
			}
		}
	}//初始化
	for (int i = 0; i < m; i++) {
		cin>>u>>v>>w;
		G[u][v]=w;
		G[v][u]=w;
	}//赋值
	cout<<prim();
	return 0;
}

标签:输出,第三次,int,样例,BT,实验,二叉树,100
来源: https://www.cnblogs.com/erxuerxu/p/16460789.html