北航机试

1301

题目描述：给一个真分数的分子分母，输出约分后的分子分母。

输入	输出
3 6	1/2
15 25	3/5

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<time.h>
#include<vector>
#include<queue>
using namespace std;

int main(){
	int a,b,i=0;
	scanf("%d %d",&a,&b);
	for(i = a;i>1;i--){
		if(b%i==0){
			b = b/i;
			a = a/i;
		}
		if(a==1){
			break;
		}
	}
	printf("%d/%d",a,b);
return 0;}

1302

题目：简单八皇后
描述：如何能够在8 X 8的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他已经正确地放置了七个皇后，编写程序求出最后一个皇后的位置。
注意： 皇后能横、竖、斜着走
`输入：按照棋盘行从小到大的顺序从控制台输入已正确放置的皇后的列数，未放置皇后的行用字符“”来表示。各列数和字符“”之间没有任何其他字符分隔，在输入末尾有回车换行符。假如上图第四行未放置皇后，其他七个皇后都已经放置完毕，则输入的形式为：627*4853
输出：在标准输出上输出最后一个皇后放置的列数，若无解，输出字符串“No Answer”

输入	输出
627*4853	1
3681*752	4
1357246*	No Answer

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<time.h>
#include<vector>
#include<queue>
using namespace std;
int main(){
	int a[8][8] ={0};
	int num1 = 0,num2 = 0,num3 = 0,i = 0;
	int place;
	char c[9];
	scanf("%s",c);
	for(i = 0;i < 8;i++){
		if(c[i]!='*'){
			while(1){
				a[1][num1] = 1;
				a[num1][c[i]-'1'] = 1;
				num1++;
				if(num1 ==8){
					break;
				}
			}
			num1 = i;
			num2 = c[i] - '1';
			while(num1<8&&num2<8){
				a[num1++][num2++] = 1;
			}
			num1 = i;
			num2 = c[i] - '1';
			while(num1!=0 &&num2!=0){
				num1--;
				num2--;
				a[num1][num2] = 1;
			}
		}else{
			place = i;
			continue;
		}
			a[i][c[i]-'1'] = 2;
	}
	for(num2 = 0;num2 <8;num2++){
		if(a[place][num2] == 0){
			num3 = num2+1;}
	}
	if(num3 == 0){
	printf("No Answer");
	}else{
	printf("%d",num3);}

return 0;}

算法提示：可将同行同列还有斜线上的格子填满

1303 科学计数法

题目描述：给出一个标准输入的正数（开头末尾没有多余的0），输出其科学计数法表示结果。
样例：

输入	输出
0.000002	2e-6
123.456	1.23456e-2
123456	1.23456e5
1.0102	1.0102
10000	1e4

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<time.h>
#include<vector>
#include<queue>
using namespace std;
int main(){
	char c[101];
	int i,temp;
	bool bol = false;
	scanf("%s",c);
	if(c[0] >= '1'&&c[0]<='9'&&c[1] == '.'){
		printf("%s",c);
	}else if(c[0] =='0'&& c[1] == '.'){
		for(i = 2;i < strlen(c);i++){
			if(c[i]!='0'){
				if(i == strlen(c)-1){
					printf("%c",c[i]);
				}else{
					printf("%c.",c[i]);}
				break;
			}
		}
		temp = i;
		i++;
		for(i = i;i < strlen(c);i++){
			printf("%c",c[i]);
		}
		printf("e-%d",i-2);
	}else{
		temp = 0;
		for(i = 0;i < strlen(c);i++){
			if(i == 1){
				printf(".");}
			if(c[i] == '.'){
				temp = i;
			}else{
				printf("%c",c[i]);
			}
		}
		if(temp == 0){
			printf("e%d",strlen(c)-1);
		}else{
			printf("e%d",temp-1);
			}
	}
return 0;}

这个题差一点，对于大于1的后面都是0的整数未考虑，比如1000

14阶乘数

输入一个正整数，输出时，先输出这个数本身，跟着一个逗号，再输出这个数的各位数字的阶乘和，等号，阶乘和的计算结果，并判断阶乘和是否等于原数，如果相等输出Yes，否则输出No。题目说明输入的正整数以及其各位阶乘和都不会超出int型的表示范围。
输入样例1：
145
输出样例1：
145,1!+4!+5!=145
Yes
输入样例2：
1400
输出样例2：
1400,1!+4!+0!+0!=27

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdio.h>
#include<string.h>
int result(int re){
	if(re ==0||re == 1){
		return 1;
	}else{
		return re * result(re-1);
	}
}


int main(){
	char c[100];
	int i,num = 0;
	scanf("%s",c);
	printf("%s,",c);

	for(i = 0;i < strlen(c);i++){
		num += result(c[i]-'0');
		printf("%c!",c[i]);
		if(i != strlen(c)-1){
			printf("+");
		}else{
			printf("=%d\n",num);
			bool bol = true;
			for(int i1 =strlen(c)-1;i1 !=-1;i1--){
				if(c[i1]-'0' != num%10){
					bol = false;
					break;
				}
				num = num/10;
			}
			if(bol){
				printf("Yes");
			}else{
				printf("No");
			}
		}

	}
return 0;
}

这个题很简单，用了一点递归，用char还是int取决于测试数据的大小，最好还是用char数组来接收，

14 五子棋

题目描述：
输入一个19*19的矩阵，只包含数字0、1、2，表示两人下五子棋的棋牌状态，1、2分别表示两人的棋子，0表示空格。要求判断当前状态下是否有人获胜（横向、竖向或者斜线方向连成5个同色棋子）。题目说明输入样例保证每条线上至多只有连续5个同色棋子，并且保证至多只有1人获胜。如果有人获胜，输出获胜者（1或2）加一个冒号，接着输出获胜的五连珠的第一个棋子的坐标，从上到下从左到右序号最小的为第一个，序号从1开始编号。如果无人获胜，输出no。

#include<stdio.h>
#define colMax  19
#define rowMax  19
int a[19][19];
int srow,scol;
bool judge(int direct,int row,int col,int per){
	int temp1 = row;
	int temp2 = col;
	int num = 0;
	if(direct == 1){
		srow = temp1;
		scol = temp2;
		while(temp2!=-1&&a[temp1][temp2] == per){
			num++;
			scol = temp2;
			temp2--;
		}
		while(temp2!=19&&a[temp1][temp2] == per){
			num++;
			temp2++;
		}
	}
	if(direct == 2){
		srow = temp1;
		scol = temp2;
		while(temp1!=-1&&a[temp1][temp2] == per){
			num++;
			srow = temp1;
			temp1--;
		}
		while(temp1!=19&&a[temp1][temp2] == per){
			num++;
			temp1++;
		}

	}
	if(direct == 3){
		srow = temp1;
		scol = temp2;
		while(temp1!=-1&&temp2!=-1&&a[temp1][temp2] == per){
			num++;
			scol = temp2;
			srow = temp1;
			temp1--;
			temp2--;
		}
		while(temp1!=19&&temp2!=19&&a[temp1][temp2] == per){
			num++;
			temp1++;
			temp2++;
		}

	}
	if(direct == 4){
		srow = temp1;
		scol = temp2;
		while(temp1!=-1&&temp2!=19&&a[temp1][temp2] == per){
			num++;
			scol = temp2;
			srow = temp1;
			temp1--;
			temp2++;
		}
		while(temp1!=19&&temp2!=-1&&a[temp1][temp2] == per){
			num++;
			temp1++;
			temp2--;
		}

	}
	if(num == 5){
		return true;
	}
	return false;

}
int main(){
	int row,col;
	for(row = 0;row < rowMax;row++){
		for(col = 0;col<colMax;col++){
			scanf("%d",&a[row][col]);
		}
	}
	int per = 1;
	int sheng = 0;
	while(sheng == 0 && per !=3){
		for(row = 0;row !=19;row++){
			if(sheng!=0){
				break;}//获胜则跳出第一层循环
			for(col = 0;col !=19;col++){
				if(a[row][col] == per){
					if(judge(1,row,col,per)){
						sheng = per;
						break;
					}//获胜跳出第二层循环
					if(judge(2,row,col,per)){
						sheng = per;
						break;
					}//获胜跳出第二层循环
					if(judge(3,row,col,per)){
						sheng = per;
						break;
					}//获胜跳出第二层循环
					if(judge(4,row,col,per)){
						sheng = per;
						break;
					}//获胜跳出第二层循环
				}
			}
		}
		per++;
	}
	if(sheng == 0){
		printf("no");
	}else{
		printf("%d,%d %d",sheng,srow+1,scol+1);
	}
return 0;
	

}

只是繁琐，并无难点

14排版

输入若干行字符，表示某电影的演职员表，每行只有一个冒号，冒号前面是职位，冒号后面是姓名，要求把各行冒号对齐，删除多余空格后输出。
先输入一个字，表示排版要求的冒号位置该位置号保证比各行冒号前的最大字符数还要大。再输入若干行字符，最多50行，每行最多100个字符，除空格、制表符和回车之外都是有效字符，要求每行的冒号处于格式要求的位置，冒号两边与有效单词之间各有一个空格，冒号前面的单词之间只有一个空格（删除多余的空格和制表符），在冒号左边右对齐，前面全由空格填充，冒号后面的单词之间也只有一个空格，在冒号右边左对齐，最后一个单词后不加空格直接换行。

#include<stdio.h>
int main(){
	int pos;
	scanf("%d",&pos);
	char c[100];
	int len = 0,i;
	int place = 0;
	int temp = 0,m;
	getchar();
	while(scanf("%c",&c[len])!=EOF){
		
		switch(c[len]){
			case '\n':	
							if(c[place-1] != ' '){
								temp = pos - place-1;
							}else{
								temp = pos - place;
							}
							for(i =0;i < temp;i++){
								printf(" ");
							}
							for(i = 0;i < len;i++){
								if(c[i] ==':'){
									if(c[i-1]!=' '){
										printf(" ");
									}
								}	
								printf("%c",c[i]);
								if(c[i] ==':'){
									if(c[i+1]!=' '){
										printf(" ");
									}
								}
								if(i == len-1){
									printf("\n");
								}
							}
							len = 0;
						break;
			case ' ':if(len == 0){
					 }else if(c[len-1]!=' '){
						len++;
					 }else{
					 }break;
			case '	':break;
			case ':':place = len;len++;break;
			default:len++;break;
		}
	
	}
return 0;}

比较麻烦但没什么难点，不过没有范例，只能按自己理解的去做了

15单词排序

输入一篇可能未经排版的文章，挑选出其中的单词【单词中不包含“（”等特殊符号】，然后按字典序输出。

熟悉string.h的函数即可
qsort用法（字符串排序）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int cmp(const void *a,const void *b){
	return strcmp((char *)a,(char *)b);
}
int main(){
	char c[10][10] = {"abc","acd","aaa","aaaaaaaaa","nibihi","hello","sdadsd","wertyu","oiu","rtyuio"};
	qsort(c,10,sizeof(c[0]),cmp);
	for(int i= 0;i < 10;i++){
	
	printf("%s\n",c[i]);}
	
	
return 0;
}

15窗口点击模拟

在计算机屏幕上，有 N 个窗口。窗口的边界上的点也属于该窗口。窗口之间有层次的区别，
在多于一个窗口重叠的区域里，只会显示位于顶层的窗口里的内容。当你用鼠标点击某个点
的时候，若其在窗口内，你就选择了处于被点击位置所属的最顶层窗口，并且这个窗口就会
被移到所有窗口的顶层，而剩余的窗口的层次顺序不变，如果你点击的位置不属于任何窗口
计算机就会忽略你这次点击。编写一个程序模拟点击窗口的过程：先从标准输入读入窗口的
个数，窗口编号和位置（以窗口的左上角和右下角的坐标表示，先输入的窗口层次高），然后
3
读入点击的次数和位置（以点击的坐标表示），编写程序求得经过上述点击后的窗口叠放次序。
【假设】：
1、屏幕左下角作为 X 轴和 Y 轴坐标原点，即坐标为（0，0），所有输入的坐标
数值都是整数，并且都大于等于 0，小于等于 1000。
2出窗口的叠放次序时从最后点击后最顶层的窗口编号开始按层次依次输出；
3、输入的窗口个数大于 0 并且小于等于 10，点击次数大于 0 并且小于等于 20。
【输入】
第一行窗口个数 n，接下来 n 行每行一个窗口的编号、左下角坐标、右上角坐标。
接下来一行点击次数 k，接下来 k 行每行一个点击坐标。
【输出】
一行 n 个数字，表示 K 次点击后按层次排列的窗口编号，空格隔开。
行末空格与文末换行可有可无。
【样例】
标准输入
4
1 43 31 70 56
2 50 24 80 50
3 23 13 63 42
4 57 36 90 52
4
47 28
73 40
68 32
82 43
标准输出
4 2 3 1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Wnd{
	int lx,ly;
	int rx,ry;
	int number;
	int num;
}wnd[100];
int len = 0;
bool bol = true;
int search(int x,int y){
	for(int i =0;i<len;i++){
				
		if(x>wnd[i].lx&&x<wnd[i].rx&&y>wnd[i].ly&&y<wnd[i].ry){
			wnd[i].number = 4;
			
			for(int m = 0;m < i;m++){
				wnd[m].number--;

			}
			return 0;
		}
	}
	return 0;
}
int cmp(const void* a,const void* b){
	struct Wnd *c = (Wnd *)a; 
	struct Wnd *d = (Wnd *)b; 
	return c->number<d->number?1:-1;
}

int main(){
	int time,int num;
	int m,n,i,n1;
	scanf("%d",&time);
	for(i = 0;i < time;i++){
		scanf("%d %d %d %d %d",&wnd[len].num,&wnd[len].lx,&wnd[len].ly,&wnd[len].rx,&wnd[len].ry);
		wnd[len].number =  wnd[len].num;
		len++;
	}
	qsort(wnd,100,sizeof(wnd[0]),cmp);
	for(n1 = 0;n1 <len;n1++){
		printf("%d %d %d %d %d %d\n",wnd[n1].number,wnd[n1].num,wnd[n1].lx,wnd[n1].ly,wnd[n1].rx,wnd[n1].ry);}
	scanf("%d",&num);
	for(i = 0;i<num;i++){
		scanf("%d %d",&m,&n);
		search(m,n);
		qsort(wnd,100,sizeof(wnd[0]),cmp);
		for(n1 = 0;n1 <len;n1++){
		printf("%d %d %d %d %d %d\n",wnd[n1].number,wnd[n1].num,wnd[n1].lx,wnd[n1].ly,wnd[n1].rx,wnd[n1].ry);
		//printf("%d ",wnd[n1].num);
	}
	}
	for(n1 = 0;n1 <len;n1++){
		
		//printf("%d ",wnd[n1].num);
	}
return 0;
}

qsort的排序会把所有的都输出，反过来排序就是输出全0
正序版本

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Wnd{
	int lx,ly;
	int rx,ry;
	int number;
	int num;
}wnd[100];
int len = 0;
bool bol = true;
int search(int x,int y){
	for(int i =0;i<len;i++){
				
		if(x>wnd[i].lx&&x<wnd[i].rx&&y>wnd[i].ly&&y<wnd[i].ry){
			wnd[i].number = 1;
			
			for(int m = 0;m < i;m++){
				wnd[m].number++;

			}
			return 0;
		}
	}
	return 0;
}
int cmp(const void* a,const void* b){
	struct Wnd *c = (Wnd *)a; 
	struct Wnd *d = (Wnd *)b; 
	return c->number>d->number?1:-1;
}

int main(){
	int time,int num;
	int m,n,i,n1;
	scanf("%d",&time);
	for(i = 0;i < time;i++){
		scanf("%d %d %d %d %d",&wnd[len].num,&wnd[len].lx,&wnd[len].ly,&wnd[len].rx,&wnd[len].ry);
		wnd[len].number =  wnd[len].num;
		len++;
	}
	qsort(wnd,len,sizeof(wnd[0]),cmp);
	for(n1 = 0;n1 <len;n1++){
		printf("%d %d %d %d %d %d\n",wnd[n1].number,wnd[n1].num,wnd[n1].lx,wnd[n1].ly,wnd[n1].rx,wnd[n1].ry);}
	scanf("%d",&num);
	for(i = 0;i<num;i++){
		scanf("%d %d",&m,&n);
		search(m,n);
		qsort(&wnd[0],len,sizeof(wnd[0]),cmp);
		for(n1 = 0;n1 <len;n1++){
		printf("%d %d %d %d %d %d\n",wnd[n1].number,wnd[n1].num,wnd[n1].lx,wnd[n1].ly,wnd[n1].rx,wnd[n1].ry);
		//printf("%d ",wnd[n1].num);
	}
	}
	for(n1 = 0;n1 <len;n1++){
		
		//printf("%d ",wnd[n1].num);
	}
return 0;
}

15相亲数

题意】
如果对于两个大于 1 的正整数 x 和 y，x 除了本身以外的因子之和等于 y，y 除了本身以外的
因子之和等于 x，则称 x 和 y 是一对相亲数。比如 220 除了本身以外的因子之和 110+55+44+22+20+11+10+5+4+2+1=284，而 284 除了
本身以外的因子之和 142+71+4+2+1=220，则 220 和 284 就是一对相亲数。
请你编写一个程序计算 x 和 y 分别除了本身以外的因子之和，并判断 x 和 y 是不是一对相亲数。x 和 y 为大于 1 的 int 范围内的整数。
【输入】
x 和 y，空格隔开。
【输出】
第一行输出 x，一个逗号，x 的除了本身以外的因子之和的计算过程（见题意，要求降序输出每个因子），不要有多余的空格。
第二行输出 y，一个逗号，y 的除了本身以外的因子之和的计算过程（见题意，要求降序输出每个因子），不要有多余的空格。
第三行，如果 x 和 y 是一对相亲数输出 1，否则输出 0。文末换行可有可无。
【样例 1】
标准输入
220 284
标准输出
220,110+55+44+22+20+11+10+5+4+2+1=284
284,142+71+4+2+1=220
1
【样例 2】
标准输入
84 1120
标准输出
11849296+148+74+37+32+16+4+2+1=1210
1220,560+280+224+160+140+112+80+70+56+40+35+32+28+20

在这里插入代码片

略，这个只要将小于x，y的数字都验证一下是不是因数，然后判断一下结果就行，可以直接判断x/2，剪枝

16逆序数

题目描述
给定一个数n，将这个数的各位顺序颠倒，称为逆序数m。
例如1234的逆序数是4321。
输入
输入一个数n(0 < n<1000000000)，已知输入开头不包含多余的0。
输出
如果m是n的k倍（k为整数），那么输出nk=m。
如果m不是n的整数倍，那么输出n和n的逆序数。
样例输入
1234
1089
23200
样例输出
1234 4321
10899=9801
23200 00232

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int change(char c[]){
	int num = 0;
	for(int i = 0;i <strlen(c);i++){
		num = 10*num + c[i]-'0';
	}
	return num;
}
int main(){
	char a[2][10];
	int i;
	while(scanf("%s",a[0])!=EOF){
		int a1 = change(a[0]);
		for(i = 0;i < strlen(a[0])/2;i++){
			char temp = a[0][i];
			a[0][i] = a[0][strlen(a[0])-1-i];
			a[0][strlen(a[0])-1-i] = temp;
			
		}
		int a3 = change(a[0]);
		if(a3%a1 == 0){
			printf("%d*%d=%d\n",a1,a3/a1,a3);
		}else{
			printf("%d ",a1);
			for(i = 0;i < strlen(a[0]);i++){
			if(a[0][i] == '0'){
				printf("0");}
			}
			printf("%d\n",a3);
		}
		
	}
	return 0;
}

比较简单

16字符串的解析

题目描述
给一个c语言的enum定义语句，输出enum中规定的各项值。
输入
输入一个c语言的enum定义语句。
输出
输出enum中规定的各项值。
样例输入
enum BOOL{true,false};
样例输出
true 0
false 1
主要是要清楚enum的用法

17年01题：数组中值

从一个无序不重复数组中，输出中间的数和它在数组中的次序（从1开始）如果是偶数个元素，则输出两个，奇数则输出中间一个
样例：

输入	输出
1 5 6 4 3 2 7 9 11	5 5
1 5 6 4 3 2 7 9 11 8	5 5 6 6

#include <stdio.h>
#include <stdlib.h>
struct node{
	int data;
	int number;
}a[200];
int len = 0;
int cmp(const void* a,const void* b){
	node* c = (node*)a;
	node* d = (node*)b;
	return (*c).data<(*d).data?1:-1;
}
int main(){
	int i = 0,m,n;
	while(scanf("%d",&a[len].data)!=EOF){
		len++;
		a[len-1].number = len;
	}
	qsort(a,len,sizeof(a[0]),cmp);
	if(len%2 == 1){
		printf("%d %d\n",a[len/2].data,a[len/2].number);
	}else{
		printf("%d %d\n",a[len/2-1].data,a[len/2-1].number);
		printf("%d %d\n",a[len/2].data,a[len/2].number);
	}


return 0;
}

这个题很简单，简单的排序问题

语义分析

这是看到的做的最好的一篇，自认做不到，尤其是还有时间限制的情况下

17二叉树的创建、遍历

题目：输入若干行，每一行的第一个输入为家谱中的某个成员，该行接着输入的信息为每个孩子姓名。
最后一行的输入为要求查找的两个家谱成员的关系。
要求，根据输入的家谱成员的信息，建立二叉树家谱关系图，并输出二位待查找成员在家谱中的关系，包括输出他们最近邻的共同祖先以及在家谱中相差的层次数。

在这里插入代码片

原博客主代码

18机试

找最长折线

#include<stdio.h>

struct Node{
	int num;
	int bx,by,dx,dy;
}node[100];
int len = 0;
int max = 0;
int mx,my;
int  search(int x,int y){
	int i = 0;
	while(i<len){
		if(node[i].dx == x&&node[i].dy == y){
			return i;
		}
		i++;
	}
return -1;
}
void insert(int bx,int by,int dx,int dy){
	int  n = search(bx,by);
	if(n!=-1){
		node[n].num++;
		node[n].dx = dx;
		node[n].dy = dy;
		if(node[n].num>max){
			max = node[n].num;
			mx = node[n].bx;
			my = node[n].by;
		}
	}else{
		node[len].num = 1;
		node[len].dx = dx;
		node[len].dy = dy;
		node[len].bx = bx;
		node[len].by = by;
		len++;
	}
}

int main(){
	int bx,by,dx,dy;
	while(scanf("%d %d %d %d",&bx,&by,&dx,&dy)!=EOF){
		insert(bx,by,dx,dy);
		printf("%d %d %d\n",max,mx,my);
	}
	
	
return 0;}

1802 燕子筑巢

#include <stdio.h>
#include <queue>
#include <stdlib.h>
using namespace std;
struct	Node{
	int child[3];
	int childnum;
	int height;
	int preorder;
};
int order = 1;
Node node[1001];
int root = -1;
void grade(int r){
	queue<int> q;
	q.push(root);
	while(!q.empty()){
		int temp = q.front();

		q.pop();
		for(int i =0;i < node[temp].childnum;i++){
			q.push(node[temp].child[i]);
			node[node[temp].child[i]].height = node[temp].height+1;
		}
	}
	return;
}
void preorder(int root){
	for(int i = 0;i < node[root].childnum;i++){
		node[node[root].child[i]].preorder = ++order;
		preorder(node[root].child[i]);
	}
	return;
}
int cmp(const void* a,const void* b){
	Node* c = (Node *)a;
	Node* d = (Node *)b;
	
	if(c->childnum > d->childnum){
		return -1;
	}else if(c->childnum == d->childnum){
		if(c->height > d->height){
			return -1;
		}else if(c->height == d->height){
			if(c->preorder<d->preorder){
			return -1;}
		}
	}
	return 1;
}
int main(){
	int n,i,m,a;
	scanf("%d",&n);
	int in[4];
	for(i = 0;i < n;i++){
		int b = 0;
		int childnum = 0;
		while(b!=4){
			scanf("%d",&in[b]);
			if(in[b]!=0&&b!=0){
				node[in[0]].child[childnum] = in[b];
				childnum++;
			}
			b++;
		}
		node[in[0]].childnum = childnum;
		if(root == -1){
			root = in[0];
			node[in[0]].height = 1;
			node[in[0]].preorder = 1;
		}
	}

	grade(root);

	preorder(root);
	qsort(node,1001,sizeof(node[0]),cmp);

	printf("%d",node[0].preorder);
	return 0;
}

二叉树相关（前中后层序遍历和燕子筑巢的排序问题）

#include<stdio.h>
#include<queue>
#include<vector>
using namespace std;
struct Node{
	int data;
	Node* lchild;
	Node* rchild;
	int preorder;
	int height;
	int miorder;
	int baorder;
};
vector<Node*> vn;
int preordernum = 1;
int miordernum = 1;
int baordernum = 1;
Node* root = NULL;
Node* create(int data){
	Node* node = new Node;
	node->data = data;
	node->lchild = NULL;
	node->rchild = NULL;
	return node;
}
Node* find(int data,Node* root1){
	if(root1->data == data){
		return root1;
	}else{
	if(root1->lchild!=NULL){
		find(data,root1->lchild);
	}if(root1->rchild!=NULL){
		find(data,root1->rchild);
	}
	}
}
void insert(int parent,int data1,int data2){
	if(root == NULL){
		root = create(parent);
		root->lchild = create(data1);
		root->rchild = create(data2);
	}else{
		Node* node = find(parent,root);
		node->lchild = create(data1);
		node->rchild = create(data2);
	}
	
}
void preorder(Node* node){
	node->preorder = preordernum;
	preordernum++;
	if(node->lchild!=NULL){
		preorder(node->lchild);
	}
	if(node->rchild!=NULL){
		preorder(node->rchild);
	}
	

}
void gradation(Node* node){
	queue<Node*> q;
	node->height = 1;
	q.push(node);
	while(!q.empty()){
		Node* node = q.front();
		q.pop();
		if(node->lchild!=NULL){
			node->lchild->height = node->height+1;
			q.push(node->lchild);
		}
		if(node->rchild!=NULL){
			q.push(node->rchild);
			node->rchild->height = node->height+1;
		}
	}	
}
void miorder(Node* node){
	if(node->lchild!=NULL){
		miorder(node->lchild);
	}
	node->miorder = miordernum++;
	if(node->rchild!=NULL){
		miorder(node->rchild);
	}
}
void baorder(Node* node){
	if(node->lchild!=NULL){
		baorder(node->lchild);
	}
	if(node->rchild!=NULL){
		baorder(node->rchild);
	}
	node->baorder = baordernum++;
}
void findheight(Node* node,int height){

	if(node->height == height){
		vn.push_back(node);
	}
	if(node->lchild!=NULL){
		findheight(node->lchild,height);
	}
	if(node->rchild!=NULL){
		findheight(node->rchild,height);
	}
}
int  searchMax(){
	int max = 0;
	for(int i = 0;i< vn.size();i++){
		if(vn[i]->preorder>max){
			 max = vn[i]->preorder;
		}
	}
	return max;
}
Node* searchNode(int preorder){
	for(int i = 0;i < vn.size();i++){
		if(vn[i]->preorder == preorder){
			return vn[i];
		}
	}
}
void prin(Node* node){
	printf("结点%d 中序%d 前序%d 后序%d 层序%d\n",node->data,node->miorder,node->preorder,node->baorder,node->height);
	if(node->lchild!=NULL){
		prin(node->lchild);
	}
	if(node->rchild!=NULL){
		prin(node->rchild);
	}
}
int main(){
	int data1,data2,data3;
	while(scanf("%d %d %d",&data1,&data2,&data3)!=EOF){
		insert(data1,data2,data3);
	}
	preorder(root);
	miorder(root);
	baorder(root);
	gradation(root);
	prin(root);
	scanf("%d",&data1);
	findheight(root,data1);
	Node* node = searchNode(searchMax());
	printf("%d",node->data);
	
	return 0;
}