华科计算机考研复试历年上机题汇总

华科历年上机题汇总（欢迎补全）
代码都很多是我自己写的，不一定正确啊！错了可不负责任的，呵呵~~~仅供参考！
==》10年保送生上机试题
1、不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。

#include<stdio.h>
#include<stdlib.h>
int main(){
char s1[200],s2[100];
int i,len1,len2;
scanf("%s %s",s1,s2);
for(i=0;i<200;i++){
if(s1[i]=='\0'){
len1=i;
break;
}
}
for(i=0;i<100;i++){
if(s2[i]=='\0'){
len2=i;
break;
}
}
for(i=len1;i<len1+len2;i++){
s1[i]=s2[i-len1];
}
printf("%s\n",s1);
system("pause");
}
2、输入一串数，要求建平衡二叉排序树，然后先序遍历。

3.、有4个小问，是超长整数的存储、计算、输出。

要把超长整数存在一个单向循环链表中，是每四位一个节点。

注：我是用单链表写的！感觉单循环链表没有什么用处么~~~
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXLEN 100
typedef struct node{
int data;
struct node *next;
}LNode,*LinkList;
int changeString(char s[],int len){//把字符串长度变成4的整数倍；
int i,temp;
char ss[MAXLEN];
if(len%4!=0){
temp=4-len%4;//需要在前面添加的0的个数；
for(i=0;i<len;i++){
ss[i]=s[i];
}
for(i=0;i<temp;i++){
s[i]='0';
}
for(i=temp;i<temp+len;i++){
s[i]=ss[i-temp];
}
}
return temp;
}
LinkList createList(char *s,int len){//创建单链表；
int i,temp,add_len;
LinkList L,p,start;
if(len<=0){
return NULL;
}
add_len=changeString(s,len);
len+=add_len;
i=0;
temp=0;
while(i<4&&i<len){//给头结点赋值；
temp=temp*10+s[i]-'0';
i++;
}
L=(LinkList)malloc(sizeof(LNode));//头结点；L->data=temp;
L->next=NULL;
start=L;
temp=0;
while(i<len){//继续创建单链表；
if((i+1)%4==1){//需新建一个结点；
p=(LinkList)malloc(sizeof(LNode));
}
temp=temp*10+s[i]-'0';
if((i+1)%4==0||i==len-1){//一个结点结束；
p->data=temp;
p->next=NULL;
start->next=p;//插入结点；
start=p;
temp=0;//重新计数；
}
i++;
}
start->next=NULL;
return L;
}
LinkList reverse(LinkList L){//逆转单循环链表；
LinkList p,q,r;
if(L!=NULL){
p=L->next;
L->next=NULL;
while(p!=NULL){
q=p;
p=p->next;
q->next=L;
L=q;
//printf("**%d\n",L->data);
}
return L;
}
return NULL;
}
void display(LinkList L){//打印输出单链表；
LinkList p;
printf("%d ",L->data);
p=L->next;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
LinkList add_LNumber(LinkList L1,LinkList L2){//2大数相加，单链表实现；
LinkList L,p,q,head,r;
int c;//进位；
int temp;
L=(LinkList)malloc(sizeof(LNode));
head=(LinkList)malloc(sizeof(LNode));
head->next=NULL;
L=head;
p=L1;
q=L2;
c=0;
while(p!=NULL&&q!=NULL){
r=(LinkList)malloc(sizeof(LNode));
temp=p->data+q->data+c;
r->data=temp%10000;
//printf("***%d\n",r->data);
r->next=NULL;
c=temp/10000;
head->next=r;
head=r;
p=p->next;
q=q->next;
}
while(p!=NULL){//L1剩余部分非空；
r=(LinkList)malloc(sizeof(LNode));
temp=p->data+c;
r->data=temp%10000;
r->next=NULL;
c=temp/10000;
head->next=r;
head=r;
p=p->next;
}
while(q!=NULL){//L2剩余部分非空；
r=(LinkList)malloc(sizeof(LNode));
temp=q->data+c;
r->data=temp%10000;
r->next=NULL;
c=temp/10000;
head->next=r;
head=r;
q=q->next;
}
if(c!=0){//还有进位；
r=(LinkList)malloc(sizeof(LNode));
r->data=c;
r->next=NULL;
head->next=r;
}
return L->next;
}
int main(){
char s1[MAXLEN],s2[MAXLEN];
int len1,len2,add_len,i;
LinkList L1,L2,L;
L1=(LinkList)malloc(sizeof(LNode)); L2=(LinkList)malloc(sizeof(LNode)); printf("请输入第一个大数：\n"); scanf("%s",s1);
len1=strlen(s1);
L1=createList(s1,len1);
printf("请输入第二个大数：\n"); scanf("%s",s2);
len2=strlen(s2);
L2=createList(s2,len2);
L1=reverse(L1);
L2=reverse(L2);
//display(L1);
//display(L2);
L=add_LNumber(L1,L2);
//display(L);
L=reverse(L);
display(L);
}
==》09年
09华中科技大学复试有关题目
嵌入式方向笔试是数据库和算法概论
数据库考了查询语言，死锁，等等
算法概论：
1题：好像是螺丝和螺母问题，每个螺丝对应一个螺母，大概有100对吧，找出相应对，最后计算时空复杂度。

还有，关于排列树，好像还有个回溯法。

前面几道简答题
上机题目：
环境：TC,VC++
1.输入一串数，然后，建立链表，排序输出。

2.计算26个字母的输入次数，好像不区分大小写。

3.用一维数组存储学号和成绩，然后，按成绩排序输出。

==》09年系统结构上机试题
09年系统结构上机题１.输入四个数，分别创建四个链表A,B,C,D. 打印四个链表
２.A按升序排列，D按降序排列
３.把B中第一个数插入A中，保持A的升序排列，把C中第一个数插入D中，保持D的降序排列
４.把链表A中每个数的个位数打印出来
５.合并链表A\D，保持升序排列。

华中科技大学复试机试题目2008年
一．
1、狼过河问题（运用到回溯）
2、统计文件中单词数目
3、N阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式。

（递归）
4、链表操作
二．
第一个是一个上楼梯的种数的统计，本来是一个用递归可以解决的问题，但是题目偏偏要求编写快速算法，言下之意就是要求你把递归转化成非递归。

#include"stdio.h"
#include"stdlib.h"
#include"string.h"
main()
{
int n,i;
long a[10000];
printf("please input n :");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
if(i==1)
a[i]=1;
else if(i==2) a[i]=2;
else
a[i]=a[i-1]+a[i-2];
printf("a[%d]=%ld\n",i,a[i]);
}
printf("the sum of methords is:%ld\n",a[n]);
system("pause");
}
#include <stdio.h>
/*函数count计算一共有多少种上楼方式+++非递归方式*/
int count(int i)
{
int a[3],j;
a[1]=1;
a[2]=2;
if(i==1)
return 1;
else if(i==2)
return 2;
else
{
for(j=3; j<=i; j++)
{
a[j%3] = a[(j-1)%3] + a[(j-2)%3];
}
return a[(j-1)%3];
}
}
int main()
{
int i,j;
i=11;
j=0;
j=count(i);
printf("%d层阶梯的上楼方式一共%d种！",i,j);
getchar();
return 0;
}
第二个题是链表的，要求依照给出的结构体依次实现输入链表，保存链表，删除链表，从磁盘读取链表，显示链表这几个操作。

做这个题，如果不记得保存文件的函数，很可能做不全或者做不出来。

第三个是要求根据- | \ / 四个字符来实现题目所规定的一个长方体。

并能使这个长方体适当的放大。

这个是一个递归问题，但是我想了半天也没有做出来。

2006
第一题是对输入的5个数排序，输出的结果到文件里。

#include<stdio.h>
#include<stdlib.h>
int cmp(const void *a,const void *b){
return (*(int *)a)-(*(int *)b);
}
int main(){
int a[5],i;
//char s[5];
FILE *foutput;
printf("请输入5个待排序的数：\n");
for(i=0;i<5;i++){
scanf("%d",&a[i]);
}
qsort(a,5,sizeof(int),cmp);
if((foutput=fopen("0000华科复试机试题(4).txt","w"))==NULL){ printf("File open error!\n");
}
for(i=0;i<5;i++){
fputc(a[i]+'0',foutput);
}
fclose(foutput);
}
第二题是用链表去对上面的5个数字排序。

第三题是输入一个ip地址串，判断是否合法。

#include<stdio.h>
#include<string.h>
int IllegleChar(char c){
if((c>='0'&&c<='9')||c=='.'){
return 1;
}
else{
return 0;
}
}
int main(){
char s[20];
int len,i,j,flag,a[3],b[4],cnt;
while(gets(s)!=NULL){
len=strlen(s);
flag=1;
for(i=0;i<len;i++){
if(IllegleChar(s[i])==0){
flag=0;//判断是否含非法字符；
break;
}
}
cnt=0;
for(i=0;i<len;i++){
if(s[i]=='.'){
cnt++;//记录"."的个数；
}
}
if(cnt!=3){//判断“.”的个数是否等于3；
flag=0;
}
else{
j=0;
for(i=0;i<len;i++){
if(s[i]=='.'){
a[j++]=i;//记录“.”的下标；
}
}
for(i=0;i<3;i++){
if(a[i+1]-a[i]<=1){
flag=0;
}
}
b[0]=b[1]=b[2]=b[3]=0;//记录4部分的数值；
for(i=0;i<a[0];i++){
b[0]=b[0]*10+s[i]-'0';
}
for(i=a[0]+1;i<a[1];i++){
b[1]=b[1]*10+s[i]-'0';
}
for(i=a[1]+1;i<a[2];i++){
b[2]=b[2]*10+s[i]-'0';
}
for(i=a[2]+1;i<len;i++){
b[3]=b[3]*10+s[i]-'0';
}
for(i=0;i<4;i++){
//printf("%d\n",b[i]);
if(b[i]<0||b[i]>255){//判断每一部分数值是否在0到255之间。

flag=0;
}
}
}
if(flag==1){
printf("YES\n");
}
else{
printf("NO\n");
}
}
}
2005
第一题：对给定的一个字符串，找出有重复的字符，并给出其位置，如：输入：abcaaAB12ab12
输出：a，1；a，4；a，5；a，10
b，2；b，11
1，8；1，12
2，9；2，13
参考代码：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(){
char s[1000];
int len,i,j,k,flag,cnt,a[1000],temp;
while(gets(s)!=NULL){
len=strlen(s);
for(i=0;i<len;i++){
flag=0;//标记是否出现重复。

cnt=0;//记录重复出现次数。

temp=0;//记录字符是否在前已经出现过。

for(k=0;k<i-1;k++){
if(s[k]==s[i]){
temp=1;
}
}
for(j=i+1;j<len;j++){
if(s[j]==s[i]&&temp==0){
flag=1;
a[cnt++]=j;//记录重复出现的下标。

}
}
if(flag==1){
printf("%c,%d;",s[i],i+1);
for(j=0;j<cnt;j++){
printf("%c,%d;",s[a[j]],a[j]+1);
}
printf("\n");
}
}
}
}
第二题：输入一个四行五列的矩阵，找出每列最大的两个数，如：输入：1 2 4 9 8
-1 4 9 8 8
12 9 8 7 0
7 8 9 7 0
输出：12 9 9 8 9
7 8 9 7 8
#include<stdio.h>
#include<stdlib.h>
int cmp(const void *a,const void *b){//qsort的比较函数；
return (*(int *)a)-(*(int *)b);
}
int main(){
int a[4][5],i,j,b[5][4];
for(i=0;i<4;i++){
for(j=0;j<5;j++){
scanf("%d",&a[i][j]);
}
}
for(i=0;i<5;i++){
for(j=0;j<4;j++){
b[i][j]=a[j][i];//逆置数组a；
}
}
for(i=0;i<5;i++){
qsort(b[i],4,sizeof(int),cmp);
printf("%d %d\n",b[i][2],b[i][3]);
}
}
第三题：输入一个字符串，建立一个二叉排序树，并中序遍历输出；#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct node{//二叉树结点数据结构定义；
char value;
struct node *lchild,*rchild;
}BTNode,*BTree;
void insertNode(BTree &t,char c){//向二叉排序树中插入节点；
BTree p,q,temp;
p=(BTree)malloc(sizeof(BTNode));
p->value=c;
p->lchild=NULL;//貌似没有这2行不行，纠结了半天啊！！！
p->rchild=NULL;
if(t==NULL){
t=p;
}
else{
q=t;
while(q!=NULL){
temp=q;
if(c<q->value){
q=q->lchild;
}
else{
q=q->rchild;
}
}
if(c<temp->value){
temp->lchild=p;
}
else{
temp->rchild=p;
}
}
}
void inOrderTra(BTree t){//中序遍历二叉排序树；
if(t!=NULL){。

inOrderTra(t->lchild);
printf("%c ",t->value);
inOrderTra(t->rchild);
}
}
int main(){
char s[1000];
int len,i;
while(gets(s)!=NULL){
len=strlen(s);
BTree t;
t=NULL;
for(i=0;i<len;i++){
insertNode(t,s[i]);
}
inOrderTra(t);
printf("\n");
}
}
2000年
1. 输入n，
求y1=1!+3!+...m!(m是小于等于n的最大奇数）y2=2!+4!+...p!(p是小于等于n的最大偶数) #include<stdio.h>
int main(){
__int64 a[100],y1,y2;//存放阶乘；
int i,n,p,m;
while(scanf("%d",&n)!=EOF){
if(n%2==0){
m=n-1;
p=n;
}
else{
p=n-1;
m=n;
}
a[1]=1;
for(i=2;i<100;i++){
a[i]=a[i-1]*i;
}
y1=0;
y2=0;
//printf("m=%d,p=%d\n",m,p);
i=1;
while(i<=m){
y1+=a[i];
i+=2;
}
i=2;
while(i<=p){
y2+=a[i];
i+=2;
}
printf("y1=%I64d,y2=%I64d\n",y1,y2);
}
}
2。

输入一个5×5的矩阵，判断是否对称
#include<stdio.h>
int main(){
int a[6][6],i,j,flag;
flag=1;//标记矩阵是否对称；
for(i=1;i<=5;i++){
for(j=1;j<=5;j++){
scanf("%d",&a[i][j]);
}
}
for(i=2;i<=5;i++){
for(j=1;j<i;j++){
if(a[i][j]!=a[j][i]){
flag=0;
}
}
}
if(flag==1){
printf("YES\n");
}
else{
printf("NO\n");
}
}
3。

建立一个升序链表并遍历
#include<stdio.h>
#include<stdlib.h>
typedef struct node{//链表结点数据结构定义；
int data;
struct node *next;
}LNode,*LinkList;
void insert_node(LinkList &L,int a){//向单链表中插入结点，并保持升序；
LinkList t,temp,p;
t=(LinkList)malloc(sizeof(LNode));//新建结点；
t->data=a;
t->next=NULL;
if(L==NULL){//是第一个结点；
L=t;
}
else{
temp=L;
p=L;
if(a<=temp->data){//结点插在表头；
t->next=temp;
L=t;
}
else{
while(temp!=NULL&&temp->data<a){//向后移动；
//while(temp->data<a&&temp!=NULL){//向后移动；
p=temp;//p指向前驱；
temp=temp->next;
}
t->next=p->next;//插入结点；
p->next=t;
}
}
//printf("***\n");
}
void print(LinkList L){//遍历链表；
LinkList temp;
if(L!=NULL){
temp=L;
while(temp!=NULL){
printf("%d ",temp->data);
temp=temp->next;
}
printf("\n");
}
}
int main(){
int a;
LinkList L;
L=NULL;
printf("输入链表各结点值，以10000结束！\n");
while(scanf("%d",&a)!=EOF){
if(a==10000){
break;
}
insert_node(L,a);
}
print(L);
}
2002年
1、编一个程序，读入用户输入的，以“.”结尾的一行文字，统计一共有多少个单词，并分
别输出每个单词含有多少个字符。

（凡是以一个或多个空格隔开的部分就为一个单词）
2、#include<stdio.h>
3、#include<string.h>
4、int main(){
5、 char s[1000];
6、 int len,a[1000]={0},i,cnt;
7、 gets(s);
8、 len=strlen(s);
9、 printf("len=%d\n",len);
10、cnt=0;//记录单词数；
11、i=0;
12、while(i<len-1&&s[i]==' '){//去掉开头的空格；
13、i++;
14、}
15、while(i<len-1){
16、if(s[i]!=' '){//遇到字符；
17、a[cnt]+=1;
18、i++;
19、}
20、else{//遇到空格；
21、cnt++;//下一个单词；
22、while(i<len-1&&s[i]==' '){//去掉中间的连续空格；
23、i++;
24、}
25、}
26、}
27、printf("单词个数：%d.\n",cnt+1);
28、printf("每个单词所含有的字符数是：\n");
29、for(i=0;i<cnt+1;i++){
30、printf("%d ",a[i]);
31、}
2、守形数是这样一种整数，它的平方的低位部分等于它本身。

比如25的平方是625，低位部分是25，因此25是一个守形数。

编一个程序，找出2--100之间所有的守形数。

#include<stdio.h>
#include<stdlib.h>
int shouxingshu(int n){
int num,count,temp,a;
a=n;
num=n*n;//n的平方；
count=0;//记录n的位数；
while(n>0){
count++;
n=n/10;
}
temp=1;
while(count>0){
temp*=10;
count--;
}
if(num%temp==a){
return 1;
}
return 0;
}
}
int main(){
int i;
for(i=2;i<=100;i++){
if(shouxingshu(i)==1){
printf("%d\n",i);
}
}
//system("pause");
}
3、编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。

例如如下的先序遍历字符串：
ABC##DE#G##F###
其中“#”表示的是空格，空格字符代表空树。

建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

#include<stdio.h>
#include<stdlib.h>
typedef struct node{//二叉树结点数据结构定义；
char data;
struct node *lchild,*rchild;
}BTNode,*BTree;
void createBTree(BTree &T){
char c;
scanf("%c",&c);
if(c=='#'){
T=NULL;
}
else{
BTree t;
t=(BTree)malloc(sizeof(BTNode));
t->data=c;
t->lchild=NULL;
t->rchild=NULL;
T=t;
createBTree(T->lchild);
createBTree(T->rchild);
}
}
void inOrderTra(BTree T){
if(T!=NULL){
inOrderTra(T->lchild);
printf("%c ",T->data);
inOrderTra(T->rchild);
}
}
int main(){
BTree T;
printf("请输入二叉树的先序遍历序列：\n");
createBTree(T);
printf("中序遍历二叉树序列：\n");
inOrderTra(T);
printf("\n");
}
屏幕的格式化输出：给出一幅图形，用程序实现。

如下所示。

AA AA
AB BA AB BA
ABC CBA AA
AB BA （输入字符B）
AA
(输入字符C)
#include<stdio.h>
int main(){
char c;
int sum,i,j;
while(scanf("%c",&c)!=EOF){
sum=c-'A'+1;
for(i=0;i<sum;i++){
for(j=0;j<2*(sum-1-i);j++){
printf(" ");//输出前边的空格；
}
for(j=0;j<=i;j++){
printf("%c",'A'+j);//输出前边一串字符串；
}
for(j=0;j<i;j++){
printf(" ");//输出中间的字符串；
}
for(j=i;j>=0;j--){
printf("%c",'A'+j);
}
printf("\n");
}
for(i=sum-2;i>=0;i--){
for(j=0;j<2*(sum-1-i);j++){
printf(" ");//输出前边的空格；
}
for(j=0;j<=i;j++){
printf("%c",'A'+j);//输出前边一串字符串；
}
for(j=0;j<i;j++){
printf(" ");//输出中间的字符串；
}
for(j=i;j>=0;j--){
printf("%c",'A'+j);
}
printf("\n");
}
getchar();//接受回车符；
}
}
2。

求最长的子序列和。

比如1+3-2，结果是4；
1+3-2+5，结果是7；
-1-2-3，结果是-1.
另外要求运行时间不超过1s,就是要求算法的复杂度要好(25分）
3。

已知二叉树的前序和中序序列，要求写出后序序列。

（40分）如果给的前序和中序序列是错误的，就要输出"NO ANSWER!" #include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct node{
char data;
struct node *lchild,*rchild;
}BTNode,*BTree;
BTree createBTree(char *pre,int st1,int en1,char *in,int st2,int en2){ BTree boot;
boot=(BTree)malloc(sizeof(BTNode));
int temp;
temp=st2;
int len_left;//左子树长度；
//printf("***\n");
if((en2-st2)!=(en1-st1)){
printf("No Answer!\n");//不能构成一棵树；
exit(0);
}
if(en1-st1<0||en2-st2<0){
boot=NULL;
return boot;
}
while(temp<=en2&&in[temp]!=pre[st1]){
temp++;
}
if(temp>en2){//注意：没有等号！
printf("No Answer!\n");//不能构成一棵树；
exit(0);
}
boot->data=pre[st1];
len_left=temp-st2;
boot->lchild=createBTree(pre,st1+1,st1+len_left,in,st2,temp-1);//构造左子树；
boot->rchild=createBTree(pre,st1+len_left+1,en1,in,temp+1,en2);//构造左子树；
return boot;
}
void display(BTree T){//后序遍历二叉树；
if(T!=NULL){
display(T->lchild);
display(T->rchild);
printf("%c",T->data);
free(T);//释放结点指针；
}
}
int main(){
char pre[1000],in[1000];
int len1,len2;
BTree T;
T=(BTree)malloc(sizeof(BTNode));
while(scanf("%s%s",pre,in)!=EOF){
len1=strlen(pre);
len2=strlen(in);
T=createBTree(pre,0,len1-1,in,0,len2-1);
display(T);
printf("\n");
}
//system("pause");
}
//1 生成一个长度为21的数组，依次存入1到21
//2 建立一个长度为21的单向链表，将上述数组中的数字依次存入链表每个结点中//3 将上述链表变为单向封闭（循环）链表
//4 从头结点开始数，将第17个结点删除，将它的下一个结点作为新的头结点
//5 重复上述过程，直到该链表中只剩一个结点，显示该结点中存入的数字
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}LNode,*LinkList;
LinkList createList(int a[],int len){//创建单链表；
LinkList L,p,r;
int i;
if(len<=0){
return NULL;
}
L=(LinkList)malloc(sizeof(LNode));
L->data=a[0];
p=L;
for(i=1;i<len;i++){
r=(LinkList)malloc(sizeof(LNode));
r->data=a[i];
p->next=r;
p=r;
}
p->next=NULL;//表尾；
return L;
}
LinkList changeList(LinkList L){//把单链表变成单循环链表；
LinkList p;
p=L;
while(p->next!=NULL){
p=p->next;//p移至表尾；
}
p->next=L;
return L;
}
LinkList deleteLNode(LinkList L){//从链表中删除结点；
LinkList p,r;
int count=1;
while(count<=16){
r=p;//r指向前驱；
p=p->next;//p移至第17个结点；
count++;
}
r->next=p->next;
free(p);
return r->next;//新的头结点；
}
void display(LinkList L){//输出单链表；
if(L!=NULL){
LinkList p;
p=L;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
}
}
int a[21],i;
LinkList L,p;
for(i=0;i<21;i++){
a[i]=i+1;
}
L=createList(a,21);
L=changeList(L);
//L=deleteLNode(L);
while(L->next!=L){
L=deleteLNode(L);
}
printf("链表中最后剩下的结点是：%d\n",L->data);
//display(L);
}。