华科05-03年计算机考研复试机试

最新推荐文章于 2025-08-06 09:55:31 发布
最新推荐文章于 2025-08-06 09:55:31 发布
阅读量2.7k 收藏
点赞数
分类专栏： C/C++ 文章标签： 数据结构 system null 测试 ini qq
本文介绍如何使用链表和二叉树解决多种问题，包括链表排序、删除最大值、二叉树遍历、约瑟夫环问题等。通过具体示例展示了链表与二叉树的基本操作及应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

【1】输入一个数列以0为结束标志，建立链式线性表，查找其中最大的数并输出删除释放节点，然后对剩余的进行排序，并输出释放节点。

参考代码：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. typedef struct LinkNode{//链表结点结构体定义；   
  4.         int data;  
  5.         struct LinkNode *next;    
  6. }LinkNode,*SqList;  
  7.   
  8. void createList(SqList &L){//创建单链表的函数；   
  9.      SqList p=L,q,s;  
  10.      int value;  
  11.      scanf("%d",&value);  
  12.      if(value==0)return;  
  13.      L->data=value;  
  14.      s=NULL;  
  15.      while(1){  
  16.          int v;  
  17.          scanf("%d",&v);  
  18.          if(v==0)  
  19.               return;     
  20.          q=(SqList)malloc(sizeof(LinkNode));  
  21.          q->data=v;  
  22.          q->next=s;  
  23.          p->next=q;  
  24.          p=q;  
  25.      }  
  26.      L=L->next;  
  27. }  
  28.   
  29. void display(SqList L){//输出单链表;  
  30.      SqList p=L;  
  31.      while(p->next!=NULL){  
  32.           printf("%d->",p->data);   
  33.           SqList q=p->next;  
  34.           free(p);//释放结点；   
  35.           p=q;           
  36.      }  
  37.      printf("%d",p->data);   
  38.      free(p);//释放结点；   
  39.      printf("/n");  
  40. }  
  41.   
  42. int getMax(SqList L){//获取最大结点值；   
  43.     int MaxNum=0;  
  44.     SqList p=L;  
  45.     while(p!=NULL){  
  46.         if(p->data>MaxNum)MaxNum=p->data;    
  47.         p=p->next;           
  48.     }  
  49.     return MaxNum;  
  50. }  
  51.   
  52. void freeMax(SqList &L){//释放此链表中值最大的结点；  
  53.        
  54.      if(L!=NULL){   
  55.          SqList p,q;  
  56.          p=L;  
  57.          q=L->next;  
  58.          if(p->data==getMax(L)){  
  59.               free(p);  
  60.               L=q;                    
  61.          }  
  62.          else{  
  63.               while(q!=NULL){  
  64.                    if(q->data==getMax(L)){  
  65.                          p->next=q->next;  
  66.                          free(q);     
  67.                          break;                
  68.                    }  
  69.                    p=q;  
  70.                    q=q->next;                 
  71.               }  
  72.          }  
  73.      }   
  74. }  
  75.   
  76. void sortList(SqList &L){//对链表结点进行排序；   
  77.      SqList p,q;  
  78.      p=L;  
  79.      while(p->next!=NULL){  
  80.           q=p->next;  
  81.           while(q!=NULL){  
  82.                if(p->data>q->data){  
  83.                      int temp;  
  84.                      temp=p->data;  
  85.                      p->data=q->data;  
  86.                      q->data=temp;                
  87.                }    
  88.                q=q->next;         
  89.           }    
  90.           p=p->next;        
  91.      }  
  92. }  
  93.   
  94. int main(){  
  95.     SqList L;  
  96.     L=(SqList)malloc(sizeof(LinkNode));  
  97.     printf("创建链表：/n");  
  98.     createList(L);  
  99.     int maxnumber;   
  100.     maxnumber=getMax(L);  
  101.     printf("链表中结点的最大值：%d/n",maxnumber);  
  102.       
  103.     freeMax(L);  
  104.     printf("释放值最大的结点后的链表：/n");  
  105.     //  
  106.     sortList(L);  
  107.     printf("对剩余结点进行排序后：/n");  
  108.     display(L);  
  109.     //printf("所创建的链表：/n");  
  110.     //display(L);  
  111.     system("pause");  
  112. }  

 

【2】输入一个先序遍历数列以0为结束标志，建立二叉遍历树，并对其进行逆中序遍历，释放空间。

参考代码：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. typedef struct BiTNode{//二叉树数据结构定义；   
  4.     int data;  
  5.     BiTNode *lchild,*rchild;      
  6. }BiTNode,*BiTree;  
  7.   
  8. BiTree CreateTree(){//创建二叉树；   
  9.     int value;  
  10.     BiTree t;  
  11.     scanf("%d",&value);  
  12.     if(value==0)return NULL;  
  13.     else{  
  14.          t=(BiTree)malloc(sizeof(BiTNode));  
  15.          t->data=value;  
  16.          t->lchild=CreateTree();  
  17.          t->rchild=CreateTree();  
  18.          return t;  
  19.     }     
  20. }   
  21.   
  22. void ReInOrder(BiTree t){//逆中序遍历二叉树；   
  23.      if(t!=NULL){  
  24.           ReInOrder(t->rchild);  
  25.           printf("%d ",t->data);  
  26.           ReInOrder(t->lchild);     
  27.           free(t);      
  28.      }  
  29. }  
  30.   
  31. int main(){  
  32.     BiTree t;  
  33.     printf("请按序输入二叉树结点的值(以0为标志结束)：/n");  
  34.     t=CreateTree();  
  35.     printf("逆中序遍历二叉树：/n");  
  36.     ReInOrder(t);  
  37.     system("pause");  
  38. }  

数据测试：

【3】给出年分m和一年中的第n天，算出第n天是几月几号（提示中给出了判断闰年的方法），按 yyyy-mm-dd的格式打印出来；

参考代码：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. int ping[12]={31,28,31,30,31,30,31,30,31,30,31,30};  
  4. int run[12]={31,29,31,30,31,30,31,30,31,30,31,30};  
  5. int main(){  
  6.     int m,n,flag,i,day,days;  
  7.     while(scanf("%d %d",&m,&n)!=EOF){  
  8.           if(m%400==0)flag=1;  
  9.           else if(m%4==0&&m%100!=0)flag=1;  
  10.           else flag=0;  
  11.           if(flag==1){//是闰年   
  12.                days=0;  
  13.                for(i=0;i<12;i++){  
  14.                    days+=run[i];  
  15.                    if(days>=n){     
  16.                        break;  
  17.                    }            
  18.                }   
  19.                if(i<12){  
  20.                    days=days-run[i];  
  21.                    day=n-days;  
  22.                    printf("%d-%d-%d/n",m,i+1,day);       
  23.                }    
  24.                else printf("illegal input!/n");      
  25.           }   
  26.           else if(flag==0){//是平年;   
  27.                days=0;  
  28.                for(i=0;i<12;i++){  
  29.                    days+=ping[i];  
  30.                    if(days>=n){     
  31.                        break;  
  32.                    }            
  33.                }   
  34.                if(i<12){  
  35.                    days=days-ping[i];  
  36.                    day=n-days;  
  37.                    printf("%d-%d-%d/n",m,i+1,day);       
  38.                }    
  39.                else printf("illegal input!/n");      
  40.           }           
  41.     }  
  42.     system("pause");  
  43. }  

数据测试：

 

【4】职工有职工号，姓名，年龄.输入n个职工的信息，找出3个年龄最小的职工打印出来。

代码：

 

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3.   
  4. struct node{//职工信息数据结构；   
  5.        int id;//职工号；   
  6.        char name[20];//姓名   
  7.        int age;//年龄；   
  8. }emp[1000];  
  9.   
  10. int cmp(const void *a,const void *b){//比较函数；   
  11.     return (*(struct node *)a).age-(*(struct node *)b).age;  
  12. }  
  13.   
  14. int main(){  
  15.     int n,i;  
  16.     printf("请输入职工数及其各职工的职工号、姓名、年龄:/n");  
  17.     scanf("%d",&n);  
  18.     for(i=0;i<n;i++){  
  19.           scanf("%d %s %d",&emp[i].id,emp[i].name,&emp[i].age);             
  20.     }  
  21.     qsort(emp,n,sizeof(node),cmp);  
  22.     printf("年龄最小的三位职工是:/n");  
  23.     for(i=0;i<3;i++){  
  24.            printf("%d %s %d/n",emp[i].id,emp[i].name,emp[i].age);            
  25.     }  
  26. }  

数据测试：

 

 

【5】n个人排一圈123报数，报到3的人退到圈外，直到剩最后一个人为止。

代码：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. typedef struct node{//链表结点数据结构定义；   
  4.        int data;  
  5.        struct node *next;  
  6. }LNode,*LinkList;  
  7.   
  8. void Josephus(int n,int k,int m){//约瑟夫环问题；n：人数，k：开始计数位置，m：数到几退出一个人；   
  9.      LinkList p,q,r;//p指向表头；   
  10.      int i,cnt;  
  11.      p=(LinkList)malloc(sizeof(LNode));  
  12.      p->data=1;  
  13.      p->next=NULL;  
  14.      q=p;  
  15.      for(i=2;i<=n;i++){//创建单循环链表；   
  16.           r=(LinkList)malloc(sizeof(LNode));  
  17.           r->data=i;  
  18.           r->next=NULL;  
  19.           q->next=r;  
  20.           q=q->next;               
  21.      }  
  22.      q->next=p;  
  23.      for(i=1;i<k;i++){  
  24.          q=p;//q始终指向前驱；   
  25.          p=p->next; //p移到开始的结点；              
  26.      }  
  27.      cnt=1;  
  28.      while(q->next!=q){  
  29.           cnt++;  
  30.           q=p;  
  31.           p=p->next;  
  32.           if(cnt%m==0){//将要退出一个人；   
  33.                 printf("%d ",p->data);  
  34.                 q->next=p->next;  
  35.                 p=p->next;  
  36.                 cnt++;         
  37.           }            
  38.      }  
  39.      printf("%d/n",q->data);  
  40. }  
  41.   
  42. int main(){  
  43.     int n,k;  
  44.     printf("请输入人数n、从谁开始数k:/n");  
  45.     scanf("%d %d",&n,&k);  
  46.     Josephus(n,k,3);  
  47.     system("pause");  
  48. }  

数据测试：

 

【7】建立二叉树,并中序遍历。

代码：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. typedef struct node{  
  4.      int data;  
  5.      node *lchild,*rchild;     
  6. }BTNode,*BiTree;  
  7.   
  8. BiTree createBiTree(){//创建二叉树；   
  9.      int value;  
  10.      BiTree T;  
  11.      T=(BiTree)malloc(sizeof(BTNode));  
  12.      scanf("%d",&value);  
  13.      if(value!=0){  
  14.           T->data=value;  
  15.           T->lchild=createBiTree();  
  16.           T->rchild=createBiTree();   
  17.           return T;        
  18.      }  
  19.      else{  
  20.           return NULL;  
  21.      }  
  22. }  
  23.   
  24. void InOrderTraverse(BiTree T){//中序遍历二叉树；   
  25.      if(T!=NULL){    
  26.            InOrderTraverse(T->lchild);  
  27.            printf("%d ",T->data);     
  28.            InOrderTraverse(T->rchild);  
  29.            free(T);  
  30.      }                    
  31. }  
  32.   
  33. int main(){  
  34.     BiTree T=createBiTree();  
  35.     InOrderTraverse(T);  
  36.     system("pause");  
  37. }  

 

数据测试：

 

 

 

 

 【8】生成一个长度为21的数组，依次存入1到21；建立一个长度为21的单向链表，将上述数组中的数字依次存入链表每个结点中；将上述链表变为单向封闭(循环)链表；从头结点开始数，将第17个结点删除，将它的下一个结点作为新的头结点；重复上述过程，直到该链表中只剩一个结点，显示该结点中存入的数字。
分三个文件，一个main; 一个.h; 一个.c 文件。

参考代码：

count21.h文件：

view plain print ?
  1. #ifndef COUNT_21_H_INCLUDED  
  2. #define COUNT_21_H_INCLUDED  
  3. #define NUM 21//链表节点数；   
  4. typedef struct node{//链表结点数据结构定义；   
  5.      int data;  
  6.      struct node *next;     
  7. }LNode,*LinkList;  
  8.   
  9. LinkList CreateList();//创建单循环链表；    
  10. #endif  

count21.c文件：

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include"Count21.h"  
  4. LinkList CreateList(){//建立单循环链表；   
  5.       LinkList L,p,q;  
  6.       int i;  
  7.       L=(LinkList)malloc(sizeof(LNode));  
  8.       p=L;  
  9.       L->data=1;  
  10.       L->next=NULL;  
  11.       for(i=2;i<=NUM;i++){  
  12.            q=(LinkList)malloc(sizeof(LNode));  
  13.            q->data=i;  
  14.            q->next=NULL;  
  15.            p->next=q;  
  16.            p=p->next;                 
  17.       }  
  18.       p->next=L;//构成循环链表；  
  19.       return L;     
  20. }  

main.c文件：

 

view plain print ?
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include"Count21.h"  
  4. int main(){  
  5.     LinkList L,p,q;  
  6.     L=CreateList();  
  7.     p=L;//p指向当前节点；  
  8.     q=L;   
  9.     while(q->next!=L){  
  10.           q=q->next;              
  11.     }//q指向前驱；   
  12.     int cnt=1;  
  13.     while(q->next!=q){  
  14.          cnt++;  
  15.          q=p;  
  16.          p=p->next;               
  17.          if(cnt%17==0){  
  18.               printf("%d ",p->data);  
  19.               q->next=p->next;  
  20.               p=p->next;  
  21.               cnt++;           
  22.          }  
  23.     }  
  24.     printf("%d/n",p->data);  
  25.     system("pause");  
  26. }  

数据测试：

输入数列，以某数为结束标志,以“先进先出”方式生成单链表,输出表中各结点的值；再求表中结点的平均值、最大值、最小值。
hbhua_hua的专栏
05-05 2205
应该可以运行，，希望可以给和我一样正在学数据结构的同学有点帮助。。愿结交正学习C的朋友一起讨论。#include #include typedef struct lnode{ int data; struct lnode *next;}lnode,linklist;lnode * hua_createlist ( ){   lnode *head, *tail, *p; int e  ;  h
王道考研复试机试题解 2020版--第七章贪心策略
大西瓜不甜的博客
03-03 1450
第七章 贪心策略 1.M磅猫粮兑换N个房间的性价比最高咖啡豆问题 #include<iostream> #include<algorithm> #include<iomanip> using namespace std; const int MAXN=1000; struct JavaBean{ double weight; double co...
二叉遍历树，逆中序遍历
11-10
//输入一个数列以0为结束标志，建立二叉遍历树，并对其进行逆中序遍历，释放空间,0代表null
查找链表最大值&&链表排序
巴啦啦能量
03-12 1330
输入一个数列以0位结束标志，建立链式线性表，查找其中最大的数并输出删除释放节点，然后对剩余的进行排序，并输出释放节点。 分步骤解决： 1）初始化链表，建立头结点 2）根据输入建立链表 link *Create(link *l)，此处采用尾插法即可，直接在Create函数中输入并以此插入到尾节点后 3）查找出最大值并从链表中删除之link *Find_delete_max(link *l) 4）最有...
输入数列，以某数为结束标志, 以"后进先出" 方式生成单链表,输出表中各结点的值；再求表中首结点和尾结点的值。
hbhua_hua的专栏
05-25 1198
#include #include typedef struct node{ int data; struct node *next;}node, linklist;node * hua_linklist( ){ linklist *L = 0 ;    printf("输入数组，生成“先进后出”的单链表。当输入9则结束输入:/n"); node *s; int x;  do{  scanf("%
【a403】遍历树问题
10-04 90
Time Limit: 1 second Memory Limit: 32 MB 【问题描述】 我们都很熟悉二叉树的前序、中序、后序遍历，在数据结构中常提出这样的问题：已知一棵二叉树的前序和中序遍历，求它的后序遍历，相应的，已知一棵二叉树的后序和中序遍历，你也能求出它的前序遍历。然而，给定一棵二叉树的前序和后序遍历，你却不能确定其中序遍历序列，考虑如下图中的几棵二...
华科08年计算机考研复试机试
weixin_33727510的博客
03-18 75
【1】 输入一个十进制数，将其先转化为八进制数，然后再输出。 参考代码： #include<stdio.h> #include<stdlib.h> int main() { int a = 0 ; printf ("Please enter a decimal number:") ; scanf ("%d",&a) ; ...
华科计算机保研复试机试题目.pdf
05-22
### 华中科技大学计算机保研复试机试知识点总结 #### 一、2008年题目解析 **1. 狼过河问题（运用到回溯）** - **问题描述**：狼、羊和白菜都需要过河，但是只有一条小船，小船只能载一个人或物品过河。如果农夫不...
2003-2010年华中科技大学计算机考研复试机试题(含代码)
12-13
在华中科技大学计算机专业的考研复试中，机试题往往涵盖数据结构、算法、程序设计等方面的知识。考生需要对C/C++编程有深入的理解和实践经验，以及解决实际问题的能力。 2. C语言和C++语言编程： 从文件中提供的...
11年华科计算机复试机试
03-26
### 华中科技大学2011年计算机复试机试知识点解析 #### 一、文件操作与文本处理 在华中科技大学2011年的计算机复试机试中，第一题考查了考生对于文件操作及文本处理的基本技能。此题分为三个小部分： 1. **读取并...
华科2000-15年机试题目+王道pdf
03-03
华科2000-15年历年的机试题目+王道机试指南pdf，非官方文件，仅供参考！不知道为啥设置不了0分数下载，如果没有积分发邮件给我，gyphust@qq.com
华科计算机考研复试上机题目2000-2016 .pdf
02-28
本文基于《华科计算机考研复试上机题目2000-2016.pdf》的内容，总结了历年来的典型试题，以便于考生更好地备考。 #### 二、2000-2010年机试题概述 2000年至2010年的上机试题主要集中在数据结构与算法的基础应用上，...
08年以前华中科大的一道机试题
aiXdeweidao的专栏
09-10 673
/*08年以前的题目(1) 输入一个数列以0位结束标志，建立链式线性表，查找其中最大的数 并输出删除释放节点，然后对剩余的进行排序，并输出释放节点。*/ /*算法思想：1.头插法建立单链表 2.顺序查找一次，找出最大值，并删除该节点
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 636
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 267
/队列: 先进先出。
【数据结构初阶】--顺序表（二）
yhrxh_ymq的博客
08-05 829
本文详细讲解了顺序表的实现方法，重点介绍了尾插、头插、尾删和头删四个核心操作。内容包含：1）尾插操作的动态扩容机制，采用2倍扩容策略；2）头插操作需要整体后移元素；3）尾删只需修改size值；4）头删需要前移元素。文中提供了完整的C语言实现代码，并通过测试用例验证了各功能的正确性。最后分析了时间复杂度：尾插/删为O(1)，头插/删为O(n)，说明顺序表更适合频繁操作尾部数据的场景。作者预告后续将继续完善顺序表的其他操作接口。
数据结构——图及其C++实现 多源最短路径 FloydWarshall算法
最新发布
学习日记
08-06 864
前两篇学习的Dijkstra算法和Bellman-Ford算法都是用来求解图的单源最短路径，即从图中指定的一个源点出发到图中其他任意顶点的最短路径。Dijkstra算法不能求解带有负权重的图的最短路径，而Bellman-Ford算法弥补了这个缺点。本篇文章再来见识一下一个求解多源最短路径的算法——Floyd-Warshall算法。多源最短路径–Floyd-Warshall算法Floyd-Warshall算法是一种解决多源最短路径问题（任意两点间的最短路径）的算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值