第三次实验
作者：互联网
任意二叉树的层次遍历
题目描述
有若干个节点，每个节点上都有编号，把这些节点随意地构成二叉树，请编程输出该二叉树的层次遍历序列。
输入
第一行是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