北邮网院考研复试10-12年上机复试真题

北邮网院考研复试

2010--‐2012年上机真题及答案

复试上机指导

1.本真题只是提供辅助作用，关键还是研友平时动手能力练

习和对算法、数据结构的理解，参加过ACM的有一定优势 大家一定要在九度、北大或者杭电OJ刷题

2.上机时，可以快速阅读所有的题目，按照从易到难的次序

做题，保证会的一定得分;

3.熟悉编程环境，熟悉c、c++的常用函数;

4.为了快速测试代码的正确性，尤其是矩阵输入的情况，可

以利用标准输入重定向，

freopen(“c:\\input.txt”,”r”,stdin);加快

测试过程;

5.注意程序边界条件的测试;

6.如果你有什么疑问，或者我们提供的材料有问题，欢迎联

系我们：bwiunbuaa@https://www.360docs.net/doc/f113886493.html,或者到https://www.360docs.net/doc/f113886493.html, 给我

们留言。

2012年上机真题

1．【问题描述】

老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。 问题如下： 给一串字符串，统计其中某个字符的个数。

输入：

首先输入一个整数T，表示一共有T组数据 0

输出：

统计这个字母在这个字符串中出现的次数。

样例输入：

2

a

absd

b

bbssb

样例输出：

1

3

解题思路：

很简单，略。

代码：

#include

#include

#include

#define STRING_MAX_LENGTH 1000

int bupt_func_w121(){

int i,T;

char ch,tmp; //存放要查找的字符

char buf[STRING_MAX_LENGTH];

//freopen("/Users/bwiunbuaa/tmp/oj/bupt_w121.in","r",stdin);

scanf("%d",&T);

for(i=0;i

scanf("%c",&tmp); //过滤掉回车，这是scanf的bug吧

scanf("%c",&ch);

scanf("%c",&tmp); //过滤掉回车，这是scanf的bug吧

scanf("%s",buf);

int j,total=0;

int len = strlen(buf);

for(j=0;j

if(buf[j] == ch){

total++;

}

}

printf("%d\n",total);

}

return 0;

}

2．【问题描述】

老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。 问题如下： 给一个二叉树 请把这个棵二叉树按层来打印。如果为相同层，需要从左到右打印。一个节点是先添加左节点后添加右节点，即添加顺序与输入顺序一致。

输入：

首先输入一个整数T，表示一共有T组数据 0

输出：

对于每组 先输出一行 "Qi:"表示第i个问题 然后接下来输出每个问题二叉树每层的节点，在同一层的节点用空格分开，同一层输出在一行（每一行末尾没有空格），不同的层输出在不同行（入下面Sample O uput所示）

样例输入：

2

4 5

2 1

3 1

4 2

5 4

1 2

2 1

样例输出：

Q1:

1

2 3

4

5

Q2:

1

2

解题思路：

二叉树的使用队列进行广度优先搜索，可以完成该题的功能，但是本题目的难点是要如何区分不同层的元素，因为不同层的元素要输出在不同的行上。我们考察二叉树的广度优先遍历，发现有一个特点，即如果第k层元素一个都没出队，那么队列中必然没有k+1层元素，而且如果第k层元素刚好都出队了，队列中只有第k+1层元素，且包含所有的k+1层元素。所以从第一层开始，把根节点入队，记录当前层节点数1，然后输出这个层得所有节点，跟新队列，然后正好队列中就只有且包含所有第2层得节点数了，依次类推直到队列为空为止。大家要特别关注leverOrder()函数和普通的广度优先遍历算法的不同。

代码：

#include

#include

#define MAX_NODE 100

#define NULL_TREE_NODE -1

typedef int TElemType; //data的数据类型

/**

* 二叉树struct

*/

typedef struct BiTNode

{

TElemType data;

int flag;

int lchild, rchild; //左右孩子的坐标

}BiTNode, *BiTree;

//队列节点的定义，广度优先遍历，要用到队列

struct QNode{

struct BiTNode *p;

struct QNode *next;

};

//队列的定义

typedef struct Queue{

struct QNode *front; //队首指针

struct QNode *rear; //队尾指针

}Queue,*pQueue;

//初始化队列

void InitQueue(struct Queue *Q){

Q->front=Q->rear=(struct QNode*)malloc(sizeof(struct QNode)); Q->front->next=NULL;

}

//入队列

void EnQueue(struct Queue *Q, struct BiTNode *node){ struct QNode *nd=(struct QNode*)malloc(sizeof(struct QNode)); nd->next=NULL;

nd->p=node;

Q->rear->next=nd;

Q->rear=nd;

}

//出队列，注意判定快为空时，应有 rear=front

struct BiTNode* DeQueue(struct Queue *Q){

struct QNode *p=Q->front->next;

Q->front->next=Q->front->next->next;

struct BiTNode *t=p->p;

if(Q->rear==p){

Q->rear=Q->front;

}

free(p);

return t;

}

/**

* 判断队列是否为空

*/

int isQueueEmpty(struct Queue *Q){

if(Q->front == Q->rear){

return 1;

}

else{

return 0;

}

}

/**

* 计算队列的长度

*/

int getQueueLength(struct Queue *Q){

int i = 0;

struct QNode *p=Q->front->next;

while(p!=NULL){

p = p->next;

i++;

}

return i;

}

/*广度优先遍历*/

void leverOrder(BiTree T,int root)

{

int left_num;//当前层的节点数

pQueue Q;//定义队列Q

InitQueue(Q);

EnQueue(Q,&T[root]);//根节点入队

while (!isQueueEmpty(Q))//如果队列非空

{

left_num = getQueueLength(Q); // 当前层的节点数while(left_num-- > 0) {//将同一层的元素全部出队BiTNode* tn = DeQueue(Q);

if(left_num == 0){ //本层最后一个

printf("%d\n",tn->data);

}

else{

printf("%d ",tn->data);

}

if(tn->lchild != NULL_TREE_NODE){

EnQueue(Q,&T[tn->lchild]);

}

if(tn->rchild != NULL_TREE_NODE){

EnQueue(Q,&T[tn->rchild]);

}

}

}

}

int bupt_func_w122(){

int T,N,M;

BiTNode bt[MAX_NODE];

int i,j;

//freopen("/Users/bwiunbuaa/tmp/oj/bupt_w122.in","r",stdin);

scanf("%d",&T);

for(i=0;i

scanf("%d%d",&N,&M);

//初始化

for(j=0;j

bt[j].data = j;

bt[j].flag = 0;

bt[j].lchild = NULL_TREE_NODE;

bt[j].rchild = NULL_TREE_NODE;

}

for(j=0;j

int p,c;

scanf("%d%d",&p,&c);

if(bt[c].lchild == NULL_TREE_NODE){//左孩子

bt[c].lchild = p;

}else{

bt[c].rchild = p;

}

}

//广度优先遍历树

printf("Q%d:\n",i+1);

leverOrder(bt,1);

}

return 0;

}

3.【问题描述】

我们都学过计算机网络，了解IPV4地址的点分十进制表示法。 你的任务很简单：判断一个字符串是否是一个合法的点分十进制表示的IPV4地址。 最低的IP地址是0.0.0.0，最高的IP地址是255.255.255.255。 PS ：方便起见，认为形似00.00.00.00的IP地址也是合法的。

输入：

第一行是一个整数T，代表输入还剩下T行 以下的T行，每行都是一个字符串（不含空白字符）。字符串的长度保证不超过15，不小于1.

输出：

对于每个字符串，输出一行。 如果它是一个合法的IPV4地址，输出Yes。 否则，输出No。

样例输入：

3

59.64.130.18

f.a.t.e

1.23.45.678

样例输出：

Yes

No

No

解题思路：

本题唯一的要求就是判断ip地址有效性的时候，多考虑一些异常的情况，比如出现012.11.11.11 12.2..3等非法形式，多几个测试用例测一下

代码：

#include

#include

#include

#define IP_ADDRESS_LENGTH 16

/**

* 判断字符串ip是否是有效地ip地址

*/

int isIpAddress(char ip[]){

int i;

int len = strlen(ip);

int ipNum[4];

int ipNumFlag[4]; //记录四个数字是否都出现，避免出现12.3..4这种ip

int dotcount=0; //记录匹配到的'.'的个数

int numpos=0; //记录ip地址每个数字的位置

memset(ipNum,0,sizeof(int)*4);

memset(ipNumFlag,0,sizeof(int)*4);

for(i=0;i

if(ip[i]>='0' && ip[i] <= '9'){

if(numpos == 0 && (ip[i] == '0')){

return 0; //ip地址的数值以0开始

}

else if( numpos > 2){

return 0; //ip地址的数值超过三位

}

ipNum[dotcount] = ipNum[dotcount]*10+(ip[i]-'0');

ipNumFlag[dotcount] = 1;

numpos++;

}

else if(ip[i] == '.'){

dotcount++;

numpos = 0;

if(dotcount > 3){ //有效的地址不会多于三个'.'

return 0;

}

}

else{ //其他字符

return 0;

}

}

for(i=0;i<4;i++){

if(ipNumFlag[i]==0 || ipNum[i] < 0 || ipNum[i] > 255){ return 0;

}

}

return 1;

}

int main(){

int T;

char buf[IP_ADDRESS_LENGTH];

int i;

//freopen("/Users/bwiunbuaa/tmp/oj/bupt_w123.in","r",stdin);

scanf("%d\n",&T);

for(i=0;i

fgets(buf,IP_ADDRESS_LENGTH,stdin);

if(buf[strlen(buf)-1]=='\n') //去掉回车符，最后一行没有回车

{

buf[strlen(buf)-1]='\0';

}

int valid = isIpAddress(buf);

if(valid == 1){

printf("Yes\n");

}

else{

printf("No\n");

}

}

return 0;

}

4.【问题描述】

正义的伙伴褋祈和葬仪社的机器人Fuyuneru正在被邪恶的GHQ部队追杀。眼看着快要逃不掉了，祈就把重要的东西塞到了机器人体内，让它先跑，自己吸引火力。 假设Fuyuneru带上东西开始逃跑时所处的点为原点，朝向为正北。操纵FuyuNeru的指令有如下四种： right X: X是1-359之间的整数，Fuyuneru的前进方向顺时针转X度。

left X: X是1-359之间的整数，Fuyuneru的前进方向逆时针转X度。

forward X: X是整数(0<=X<=1000)，Fuyuneru向当前朝向前进X米。

backward X: X是整数(0<=X<=1000)，Fuyuneru向当前朝向后退X米。

现在祈向Fuyuneru体内输入了N(1<=N<=50)个这样的指令。可是由于此前Fuyuneru被GHQ部队击中，它出了一点小问题：这N个指令执行的顺序是不确定的。 问：Fuyuneru最远可能逃出多远？ 即，Fuyuneru在执行完N条指令之后，距离远点最远的可能距离是多少？

输入：

第一行是一个整数T，代表测试数据有T组。

每组测试数据中，第一行是一个整数N，代表指令有N条； 随后紧跟N行，每一行代表一个指令（格式保证是上述四种中的一种，数据保证合法）。

输出：

对于每组数据，输出一行：最远的可能逃亡距离，精确到小数点后3位。

样例输入：

3

3

forward 100

backward 100

left 90

4

left 45

forward 100

right 45

forward 100

6

left 10

forward 40

right 30

left 10

backward 4

forward 4

样例输出：

141.421

200.000

40.585

解题思路：

代码：

2011年上机真题

1.【问题描述】

读入一组字符串（待操作的），再读入一个int n记录接下来有几条命令，总共有2中命令：

1、翻转 从下标为i的字符开始到i+len-1之间的字符串倒序；

2、替换 命中如果第一位为1，用命令的第四位开始到最后的字符串替换原读入的字符串

下标 i 到 i+len-1的字符串。每次执行一条命令后新的字符串代替旧的字符串（即下一条命令在作用在得到的新字符串上）。

命令格式：第一位0代表翻转，1代表替换；第二位代表待操作的字符串的起始下标int i；

第三位表示需要操作的字符串长度int len。

输入：

输入有多组数据。

每组输入一个字符串（不大于100）然后输入n，再输入n条指令（指令一定有效）。

输出：

根据指令对字符串操作后输出结果。

样例输入：

bac

2

003

112as

样例输出：

cab

cas

解题思路：

比较简单，略。

代码：

#include

#include

#include

#include

#include

void reverse(char a[],int start,int len);

void tihuan(char a[],char b[],int start,int len);

int main()

{

char string[200];

int n;

char **cmd;

int i;

while(gets(string)!=NULL)

{

scanf("%d",&n);

cmd=(char**)malloc(sizeof(char*)*n);

for(i=0;i

{

cmd[i]=(char*)malloc(sizeof(char)*104);

}

getchar();

for(i=0;i

{

gets(cmd[i]);

}

//判断类型

for(i=0;i

{

if(cmd[i][0]=='0')

{

// if(strlen(cmd[i])==3)

reverse(string,cmd[i][1]-'0',cmd[i][2]-'0');

// else if(strlen(cmd[i])==5)

//

reverse(string,(cmd[i][1]-'0')*10+(cmd[i][2]-'0'),(cmd[i][3]-'0')*10 +(cmd[i][4]-'0'));

// else if(strlen(cmd[i])==4)

//

reverse(string,cmd[i][1]-'0',(cmd[i][2]-'0')*10+(cmd[i][3]-'0'));

}

else

tihuan(string,cmd[i],cmd[i][1]-'0',cmd[i][2]-'0');

}

for(i=0;i

{

free(cmd[i]);

}

free(cmd);

}

return 0;

}

/**

* 将字符串a从下标start，长度为len的字符串反转

*/

void reverse(char a[],int start,int len)

{

int temp1=len/2;//中间位置

int i,j,k;

char temp2;

for(i=start,j=start+len-1,k=0;k

{

temp2=a[i];

a[i++]=a[j];

a[j--]=temp2;

}

puts(a);

}

/**

* 字符串替换

*/

void tihuan(char a[],char b[],int start,int len) {

//判断被覆盖的字符数量，和要覆盖的字符数量之间的大小关系，//分成3种情况处理，

//若大于，则往前挪

//若小于，则往后挪

//若相等，无需挪动

int total_b=strlen(b)-3;

int i;

int a_move;

int gap;

if(len==total_b)

{

for(i=0;i

{

a[start+i]=b[3+i];

}

}

else if(len

{

gap=total_b-len;

a_move=start+len;

for(i=strlen(a);i>=a_move;i--)

{

a[i+gap]=a[i];

}

for(i=0;i

{

a[start+i]=b[i+3];

}

}

else

{

gap=len-total_b;

for(i=len+start;i<=(int)strlen(a);i++)

{

a[i-gap]=a[i];

}

for(i=0;i

{

a[start+i]=b[3+i];

}

}

puts(a);

}

2.【问题描述】

一个复数（x+iy）集合，两种操作作用在该集合上：

1、Pop 表示读出集合中复数模值最大的那个复数，如集合为空 输出 empty ，不为空就

输出最大的那个复数并且从集合中删除那个复数，再输出集合的大小SIZE；

2 Insert a+ib 指令（a，b表示实部和虚部），将a+ib加入到集合中 ，输出集合的大小SIZE； 最开始要读入一个int n，表示接下来的n行每一行都是一条命令。

输入：

输入有多组数据。

每组输入一个n(1<=n<=1000)，然后再输入n条指令。

输出：

根据指令输出结果。

样例输入：

3

Pop

Insert 1+i2

Pop

样例输出：

empty

SIZE = 1

1+i2

SIZE = 0

提示：

模相等的输出b较小的复数。

a和b都是非负数。

解题思路：

略。

代码：

#include

#include

int main()

{

int complex[1000][3],x,y;

char str[100];

int mmax=0,amax=0,bmax=0;

int p=0,n=0,i=0,j=0,k=0,size=0;

while(scanf("%d",&n)!=EOF)

{

size=0;

for(i=0;i

{

scanf("%s",str);

if(strcmp(str,"Pop")==0)

{

if(size==0)

{

printf("empty\n");

}

else

{

mmax=0,amax=0,bmax=0,p=0;

for(j=0;j

{

if((mmax=complex[j ][1])))

{

mmax=complex[j][2];

bmax=complex[j][1];

amax=complex[j][0];

p=j;

}

}

for(k=p;k

{

complex[k][0]=complex[k+1][0];

complex[k][1]=complex[k+1][1];

complex[k][2]=complex[k+1][2];

}

size--;

printf("%d+i%d\n",amax,bmax);

printf("SIZE = %d\n",size);

}

}

else

{

scanf("%d+i%d",&x,&y);

complex[size][0]=x;

complex[size][1]=y;

complex[size][2]=x*x+y*y;

size++;

printf("SIZE = %d\n",size);

}

}

}

return 0;

}

3.【问题描述】

给一棵树，你可以把其中任意一个节点作为根节点。每个节点都有一个小写字母，中序遍历，得到一个字符串，求所有能得到的字符串的字典序最小串。因为这棵树不一定是二叉树，所以中序遍历时，先中序遍历以节点序号最小的节点为根的子树，然后再遍历根节点，最后根据节点序号从小到大依次中序遍历剩下的子树。

输入：

多组数据，以EOF结束。 第一行一个数n（0

然后一个长度为n的串，第i（0<=i

输出：

题中要求的最小的字符串

样例输入：

3

bac

0 1

1 2

4

abcd

0 1

0 2

0 3

样例输出：

bac

bacd

提示：

意思就是请枚举所有的点为根，然后中序遍历 最后输出所有结果中字典序最小的 比如说第二组数据

以0为根时结果为 bacd

以1为根时结果为 cadb

以2为根时结果为 badc

以3为根时结果为 bacd

所以字典序最小的是bacd

解题思路：

本题的关键是根据输入的无向边，和root节点，建立树。因为无向边的两个端点，并未指定哪个是父节点，所以只能根据root节点来确定每条边两个端点的父子关系，确定原则如下3点：

* 1.如果边的两个节点包含root节点，则另一个节点的父节点为root

* 2.如果边的两个端点其中一个节点的父亲节点已经确定，则它不肯能再有父节点，只能成为另一个节点的父亲节点

* 3.如果不满足上述两个条件，则不处理该边的信息，留待后面确认父子关系，直到所有的边的节点都确定了父子关系

建立树后，中序遍历，然后比较遍历结果，输出遍历结果最小的遍历结果。多叉树的遍历相对于二叉树的遍历稍微复杂一些，各位研友务必熟练掌握，根据小编整理北邮上机试题发现，北邮的老师很钟爱树结构的题目，几乎每年都有。

代码：

#include

#include

#include

#define MAX_NODE 100

#define NULL_TREE_NODE -1

/**

* 多叉树struct

*/

typedef struct BiTNode

{

char data;

int flag;

int parent; //由于本题需要，需要记录父节点

int nextnode; //属于同一父亲节点的下一个节点

int firstchild; //第一个孩子节点的坐标

}BiTNode, *BiTree;

/**

* 树形节点无向边的数据结构

*/

typedef struct Edge

{

int l, r; //输入项目，表示l和r之间有无向边，但不确定谁是父亲节点，谁是孩子节点

int flag; //0:表示父子关系未定，1表示父子关系已经确定

}Edge, *pEdge;

/**

* 获取多叉树节点下标为node的节点的最后一个子孙节点。

*/

int getLastChild(BiTree bt,int node){

int firstChild = bt[node].firstchild;

if(firstChild == NULL_TREE_NODE){

return NULL_TREE_NODE;

}

int cur = firstChild;

while(bt[cur].nextnode != NULL_TREE_NODE){

cur = bt[cur].nextnode;

}

return cur;

}

/**

* 根据树形结构的边，根节点建立一颗树

* 因为输入的边信息，无法知道边的两个节点哪个是父亲节点，只能由父亲节点逐步确定，确定标准有两个

* 1.如果边的两个节点包含root节点，则另一个节点的父节点为root

* 2.如果边的两个端点其中一个节点的父亲节点已经确定，则它不肯能再有父节点，只能成为另一个节点的父亲节点

* 3.如果不满足上述两个条件，则不处理该边的信息，留待后面确认父子关系，直到所有的边的节点都确定了父子关系

*/

int createBiTree(BiTree bt,pEdge edge,int root,int len){ int changed=1; //循环标志，如果changed=0，表示结束

while(changed == 1){

int i;

changed = 0; //1轮遍历开始前，changed置0

for(i=0;i

if(edge[i].flag == 0){ //该边还没有被处理

int l = edge[i].l;

int r = edge[i].r;

if(l == root || r == root){ //包含 root 节点

int father = (l == root)?l:r;

int child = (l == root)?r:l;

bt[father].nextnode = NULL_TREE_NODE;

bt[child].parent = father;

bt[father].parent = NULL_TREE_NODE;

int lc = getLastChild(bt,father); //获取父亲节点的最

后一个孩子节点

if(lc == NULL_TREE_NODE){ //如果没有孩子节点，则当前child节点成为father节点的第一个孩子

bt[father].firstchild = child;

}

else{ //child节点成为当前节点的最后一个孩子

bt[lc].nextnode = child;

}

edge[i].flag = 1; //已处理

changed = 1;

break; //这点非常关键，否则可能造成孩子节点的顺序错误，很不容易发现的bug

}

else{ //其他节点

if(bt[l].parent != NULL_TREE_NODE||bt[r].parent != NULL_TREE_NODE){ //l的父亲一顶，不能再有其他父亲，所以l只能是r的父亲

int father = (bt[l].parent!= NULL_TREE_NODE)?l:r;

int child = (bt[l].parent!= NULL_TREE_NODE)?r:l;

int lc = getLastChild(bt,father);

if(lc == NULL_TREE_NODE){//如果没有孩子节点，则当前child节点成为father节点的第一个孩子

bt[father].firstchild = child;

}