东北大学考研计算机真题答案.docx
《东北大学考研计算机真题答案.docx》由会员分享，可在线阅读，更多相关《东北大学考研计算机真题答案.docx（21页珍藏版）》请在冰豆网上搜索。
东北大学考研计算机真题答案
2005年：
C语言部分
/*1.将一个数的数码倒过来所得到的新数叫原数的反序数。
如果一个数等于它的反序数，则称它为对称数。
计算不超过1993的最大的二进制的对称数。
*/
#include
intcount（intn）
{
inta[4],i=0,flag;//flag为是否是对称数的标记，若为对称数为1，否则为0
while（n!
=0）//获取n的四位数字分别放到a数组中
{
a[i]=n%10;//获取n的末位数字
n=n/10;
i++;
}
if（i==2）//n为两位数的情况
{
if（a[0]==a[1]）
flag=1;
else
flag=0;
}
elseif（i==3）//n为三位数的情况
{
if（a[0]==a[2]）
flag=1;
else
flag=0;
}
else//n为四位数的情况
{
if（a[0]==a[3]&&a[1]==a[2]）
flag=1;
else
flag=0;
}
returnflag;
}
voidmain（）
{
inti,max=0,flag;
for（i=0;i<1993;i++）
{
flag=count（i）;
if（flag==1&&i>=max）//是对称数
max=i;
}
printf（"%d",max）;
}
/*2.编写一函数不清delstring（char*pstr1,char*pstr2）功能是删除在字符串pstr1中出现的所有字符串pstr2.（不允许有字符串标准库函数）*/
voiddelstring（char*pstr1,char*pstr2）
{
intm=0,n=0,i=0,j,v;
while（pstr1[m]!
=0）m++;//m中统计pstr1的长度
while（pstr2[n]!
=0）n++;//n中统计pstr2的长度
while（（m+1-i）>n）//pstr1剩余字符数要大于pstr2字符数
{
j=0;
while（pstr1[i+j]==pstr2[j]&&j{
j++;
}
if（pstr2[j]==0）
{
for（v=i+n;v<=m;v++）//移动字符清除相同字符
pstr1[v-n]=pstr1[v];
}
else//不同,继续.
i++;
}
}
/*3.共有N种面值的邮票，存在整数R，使得用不超过M枚的上述面值的邮票可以贴出从1开始一直到R的有面值，但不能R+1。
例如:
面值（1，4，7，8）的邮票不超过3张可以贴出1~24间的所有邮资，但贴不出25。
）
请从键盘输入M和N，寻找一种确定每种邮票面值的方案，使得该方案在M和N的限制下对应的R值最大。
*/
#defineMAX_N_SIZE10
intr,a[MAX_N_SIZE];/*-----r为最大面值，a[0..n-1]存放各种面值-----*/
intfun（intm,intn）
{
inti,flag=0,m1;
m1=m;
if（m1>n）
printf（"error"）;
if（m1==n）
m1--;
for（i=0;ia[i]=1+i*m1;
for（i=m1;ia[i]=a[i-1]+1;
r=a[n-1]*m;
}
数据结构部分
/*三.设二叉树中结点的数据域的值互不相同，试设计一个算法将数据域值为X的结点的所有祖先结点的数据域打印出来。
*/
structRecord//结点
{
Record*left;
Record*right;
Record*parent;
typedata;
};
voidPrintParent（typex）
{
while（p!
=NULL&&p->data!
=x）//查找值为X的节点;
p=p->next;
if（p->data==x）
{
for（p=parent;p!
=null;p=parent->parent）
printf（"%d",data）;
}
}
四.写算法判别以邻接表方式存储的有向图中是否存在由顶点Vi到Vj的路径。
（i不等于j）
//邻接表结构
structarcnode
{
intpost;
arcnode*next;
};
structheadnode
{
typedata;
arcnode*first;
};
structgraph
{
headnodenode[n];
intnodenum,arcnum;
}g;
boolvisited[n];//访问标志
boolpath（graphg,intvi,intvj）
{
arcnodew=g.node[vi].first;
visited[vi]=true;
if（g.node[vi].data==g.node[vj].data）
returntrue;
for（;w;w=w->next）//深度遍历
if（!
visited[w->post]）
returnpath（g,w->post,vj）;
returnfalse;
}
2004年：
C语言部分
三.设有算术表达式，其中包含有大括号”{""}"中括号"[""]"小括号"（""）",试编写一个递归函数，判断表达式中的括号是否匹配
typedefcharStackEntry;
intCheck（）
{
STACKS;//定义栈结构S
charch;
InitStack（&S）;//初始化栈S
while（（ch=getchar（））!
='\n'）
{
//以字符序列的形式输入表达式
switch（ch）
{
case（ch=='（'||ch=='['||ch=='{'）:
Push（&S,ch）;break;//遇左括号入栈
//在遇到右括号时，分别检测匹配情况
case（ch=='）'）:
if（StackEmpty（S））
retrunFALSE;
else
{
Pop（&S,&ch）;
if（ch!
='（'）
returnFALSE;
}
break;
case（ch==']'）:
if（StackEmpty（S））
retrunFALSE;
else
{
Pop（&S,&ch）;
if（ch!
='['）
returnFALSE;
}
break;
case（ch=='}'）:
if（StackEmpty（S））
retrunFALSE;
else
{
Pop（&S,&ch）;
if（ch!
='{'）
returnFALSE;
}
break;
default:
break;
}
}
if（StackEmpty（S））
returnTRUE;
else
returnFALSE;
}
四.设有一个整数序列，有n个整数（0要求:
1不能改变序列的顺序;2相同的整数只保留一个。
例如：
输入序列为:
5,3,5,7,8,3,5,10,6输出为：
序列--5,3,7,8,10,6编号--2,1,4,5,6,3*/
#include
voidmain（）
{
structn
{
intdi;//存放整数
intk;//存放di的编号
}num[100]={{0,0}};//全部置零
inti=0,j=0,t,m,temp;
scanf（"%d",&temp）;
while（temp!
=-1）
//输入整数序列，输入-1表示结束,整个循环结束后，i的值就是序列中的整数个数
{
while（j<=i）
{
//从数组开头查询，是否有与temp相等的数字
if（temp!
=num[j].di）
j++;
else
break;
}
if（j>i）//没有与temp相等的数字，temp加入数组
{
num[j-1].di=temp;
i++;
j=0;//j指向数组开头，做下一次判断
scanf（"%d",&temp）;
}
else//有与temp相等的数字，j指向数组开头，做下一次判断
{
j=0;
scanf（"%d",&temp）;
}
}
for（j=1;j<=i;j++）//开始编号
{
for（t=0;t//找到第一个没有编号的数，这个循环结束后，t指向序列中最前面的没有编号的数.
if（num[t].k!
=0）//如果条件成立，说明此数已经编号，跳过！
else
break;
for（m=0;m{
if（（num[m].dit=m;
else
continue;
}
num[t].k=j;//编号
}
for（j=0;jprintf（"%d",num[j].di）;
printf（"\n"）;
for（j=0;jprintf（"%d",num[j].k）;
printf（"\n"）;
}
五.设有两个有序链表，一为升序，一为降序。
试编写程序，将这两个链表合并为一个序链表。
//假设升序的链表为链表1，降序的链表为链表2
#include
#include
#include
typedefstructlist_node
{
intdata;
structlist_node*next;
}list_node;
list_node*list1=NULL;//链表1头结点
list_node*list2=NULL;//链表2头结点
voidlist_print（constlist_node*p）//打印该链表函数
{
if（p==NULL）
return;
while（p!
=NULL）
{
printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidlist_create（list_node*&head,intdata[],intN）//创建链表
{
if（data==NULL）
return;
inti;
list_node*p;
p=（list_node*）malloc（sizeof（list_node））;
p->data=data[0];
p->next=NULL;
head=p;
for（i=1;i{
p->next=（list_node*）malloc（sizeof（list_node））;
p->next->data=data;
p->next->next=NULL;
p=p->next;
}
}
voidlist_reverse（list_node*&head）//使链表反序
{
if（head==NULL）//如果head1为空，则返回
return;
list_node*p,*q;
q=head;
p=head->next;
while（p!
=NULL）
{
head->next=p->next;//将头指针的next指向p的下一个节点
p->next=q;//将p的next值反指向它的前一个节点q
q=p;//q移向p的位置
p=head->next;//p移向它的下一个位置
}
head=q;
}
voidlist_destroy（list_node*head）//销毁函数
{
list_node*pmove=NULL,*pdel=NULL;
pmove=head;
while（pmove!
=head）
{
pdel=pmove;
free（pdel）;
pmove=pmove->next;
}
}
list_node*merge_two_list（）//合并链表1和链表2
{
list_reverse（list2）;//反转链表使之与链表1一样升序排列
list_node*list_merged;//和并后的链表
list_node*p1,*p2,*p0;
list_merged=（list_node*）malloc（sizeof（list_node））;
list_merged->data=0;
list_merged->next=NULL;
p0=list_merged;
p1=list1;
p2=list2;
while（p1!
=NULL&&p2!
=NULL）
{
if（p1->datadata）
{
p0->next=（list_node*）malloc（sizeof（list_node））;
p0->next->data=p1->data;
p0->next->next=NULL;
p0=p0->next;
p1=p1->next;
}
else
{
p0->next=（list_node*）malloc（sizeof（list_node））;
p0->next->data=p2->data;
p0->next->next=NULL;
p0=p0->next;
p2=p2->next;
}
}
while（p1!
=NULL）
{
p0->next=（list_node*）malloc（sizeof（list_node））;
p0->next->data=p1->data;
p0->next->next=NULL;
p0=p0->next;
p1=p1->next;
}
while（p2!
=NULL）
{
p0->next=（list_node*）malloc（sizeof（list_node））;
p0->next->data=p2->data;
p0->next->next=NULL;
p0=p0->next;
p2=p2->next;
}
returnlist_merged;
}
数据结构部分
二.某商店有一皮手机，按价格从高价到底构成一个单链表，结点包括数量、价格、指针。
现新到n台价格不同的手机，编写将新到手机插入到原链表中的算法。
//定义此单链表的结点结构：
typedefstructLnode
{
intnumber;//数量域
intvalue;//价格域
structLnode*next;//指针域
}Lnode,＊Linklist;
voidinsert_link（Linklist&L,intn）
{
//将新到n台价格不同的手机插到有序链表中
for（i=1;i<=n;i++）
{
scanf（&price）;//读入每台手机价格
s=（Linklist）malloc（sifeof（Lnode））;
s->value=price;
s->number=1;
p=L->next;
if（p->valuevalue）//插入首部
{
s->next=L->next;
L->next=s;
}
else
{
while（p->next&&（p->next->value>s->value））
p=p->next;
if（!
p->next）//插入表尾
{
s->next=p->next;
p->next=s;
}
elseif（p->next->value=s->value）
p->next->number++;
else
{
s->next=p->next;
p->next=s;
}
}
}//for
}
三.假设哈希函数为H（key）,编写用链地址解决冲突的哈希表的插入和删除算法。
（1）//哈希表插入，用链地址解决冲突
voidInsert_HS（HashTable&H,keytypekey）
{
i=H（key）;//获得哈希地址
if（H[i]==NULL）
{
s=（Linklist）malloc（sizeof（Lnode））;
s->data=key;
s->next=H[i];
H[i]=s;
}//if
else
{
//在链表中查找key
p=H[i];
while（p&&p->data!
=key）
p=p->next;
if（p->data==key）
exit
（1）;
else
{
//插入表头
s=（Linklist）malloc（sizeof（Lnode））;
s->next=H[i];
H[i]=s;
}//else
}//else
}
（2）//哈希表删除，用链地址解决冲突
voidDelete_HS（HashTable&H,keytypekey）
{
i=H（key）;//获得哈希地址
if（H[i]==NULL）
exit
（1）;
p=H[i];
q=p;//p为工作指针，q为p前趋
while（p&&p->data!
=key）
{
//查找
q=p；
p=p->next;
}//while
if（!
p）
exit
（1）;
if（q==H[i]）
{
//key为第一结点
H[i]=p->next;
free（p）;
}//if
else
{
q->next=p->next;
free（p）;
}//else
}
四.设用输入广义表表示的字符串来创建二叉链表结构的二叉树，具体规定如下：
广义表的表名作为树的根结点，每个结点的左子树和右子树用逗号分割，
若仅有右子树，则逗号不能省略，以特殊符号'$'表示广义表的结尾。
（1）若输入的字符串为A（B（C）,D（E（,F）,G））,画出所表示的二叉树。
（2）实现用上述方法创建二叉树的算法。
*/
（1）//画图我就不画了，你自己画吧，不难
（2）//用栈来实现
voidCreatTree（BiTree&T,char*str）
{
//生成二叉树
BiTreestack[maxsize],p;
intk,j=0,top=-1;//j为str指针，top为栈顶指针
T=NULL;//初始化
charch=str[j];
while（ch!
='$'）
{
switch（ch）
{
case'（':
top++;
stack[top]=p;//入栈
k=1;//k=1,为左孩子
break;
case'）':
top--;
break;//出栈
case',':
k=2;
break;//k=2,为右孩子
default:
p=（BiTree）malloc（sizeof（BTNode））;
p->data=ch;
p->lchild=p->rchild=NULL;
if（T==NULL）
T=p;//创建根结点
else
{
switch（k）
{
case'1':
stack[top]->lchild=p;
break;
case'2':
stack[top]->rchild=p;
break;
}
}
}//switch
j++;
ch=str[j];
}//while
}
升级会员 