计算机考研自命题(4)

最新推荐文章于 2024-11-12 21:59:57 发布

XUN~MLF

最新推荐文章于 2024-11-12 21:59:57 发布

阅读量249

点赞数

分类专栏：考研文章标签：考研算法数据结构 c语言链表

本文链接：https://blog.csdn.net/xun__mlf/article/details/133988821

版权

考研专栏收录该内容

8 篇文章 3 订阅

订阅专栏

1、C语言-通项求和

1、编写程序:求a+aa+aaa+aaa+aaa+aaa…aaa的和，需要写一个函数fn(a,n)实现n个a的拼接，例如fn(3,2)返回的结果就是36。

# include<stdio.h>

/*
解题思路：fun(a,n)
a表示构成通项的数字 
n表示有几个通项 
先让一个 temp = a,将最开始的数字保存下来
求值一次 a = a*10 + temp 
第1个通项 ： a = a
第2个通项 ： aa = a*10 +temp
然后就行求和 

假设fun(3,2)即 2 个通项全由数字 3 构成：3+33 
temp = a=3
第1个通项 ： a = 3 = 3
第2个通项 ： aa == 33 = 3*10 +temp  
*/


int fun(int a,int n){
	int i,sum = 0;
	int temp = a;
	for(i = 1;i<=n;i++){  // 求 n 个通项和 
		sum = sum+a;
		a = a*10 + temp;
	}
	
	return sum;
} 

int main() {
	int sum = fun(3,3);
	printf("sum = %d",sum);
	return 0;
}

2、C语言-结构体

2、编写程序:写一个学生的结构体，结构体成员有学号，年龄，性别，成绩。学生成绩等级的划分：90-100为A等，80-89为B等，

70-79为C等，60-69为D等，60以下为不及格。要求实现录入学生信息的功能，并写一个函数set_grade()实现根据学生成绩的进行

划分和统计不及格人数的功能。

# include <stdio.h>

/*
解题思路：
先定义学生的结构体
然后创建函数 set_grade(stu,n),传入学生讯息，和学生总人数
然后用一个数组来存储每个阶段学生的人数 
*/ 

// 学生结构体定义 
struct Student{
	int id;     // 学号 
	int age;    // 年龄 
	char sex;   // 性别 
	int grade;  // 成绩 
}Student;

//  
void set_grade(struct Student stu[],int n){
	int i,j;
	int sum[5] = {0};
	for(i = 0;i< n;i++){
		if(stu[i].grade>=90){
			sum[0]++; 
			printf("成绩大于90 A");
		}
		if(stu[i].grade>=80&&stu[i].grade<90){
			sum[1]++; 
			printf("成绩大于80小于90 B");
		}
		if(stu[i].grade>=70&&stu[i].grade<80){
			sum[2]++; 
			printf("成绩大于70小于80 C");
		}
		if(stu[i].grade>=60&&stu[i].grade<70){
			sum[3]++; 
			printf("成绩大于60小于70 D");
		}if(stu[i].grade<60){
			sum[4]++; 
			printf("成绩小于60 不及格");
		}
	}
	
	printf("不及格人数为%d",sum[4]); 
} 


int main(){
	struct Student stu[5] = {
		{1001,16,'男',91},
		{1002,16,'男',41},
		{1003,16,'男',81}, 
		{1004,16,'男',51},
		{1005,16,'男',71}
	};
	set_grade(stu,5);
	return 0;
}

3、C语言-文件操作

3、编写程序:实现输入10个数，将这10个数按照从小到大的顺序排序，并写入data.txt文件中。

/*
解题思路：定义一个数组，用来存储输入的10个数，
利用scanf()函数从键盘输入10个数字存储到数组中，然后对数组进行冒泡排序，
然后用 W+ (读写的方式)打开文件，将数组中的数字利用fprintf()函数写入文本中
*/

#include <stdio.h>
#include <string.h>
int main()
{
   FILE *fp;   // 定义文件指针
   int arr[10];
   int num;
   int i,j; 
   for(i=0;i<10;i++){
   		printf("请输入第%d个整数:\n",i+1);
   		scanf("%d",&num);
   		arr[i] = num;
   }
   // 冒泡排序  从小到大排序 
   for(i = 0;i<10;i++){
   		for(j = 0;j<10-1-i;j++){
   			if(arr[j]>arr[j+1]){
   				t = arr[j];
   				arr[j] = arr[j+1];
   				arr[j+1] = t;
		   }
	   }
   }
   fp = fopen("data.txt","w+");
   for(i = 0;i<10;i++){
   		fprintf(fp,"%d ",arr[i]);
   }
   // 关闭文件 
   fclose(fp);
   return(0);
}

4、C语言–求和

4、编写程序:实现计算2/1+3/2+5/3+8/5…的和,分子是分母与分子之和，分母是上一个分式的分子。

// 2/1 + 3/2 + 5/3 + 8/5……


/*
解题思路：
元素求和，分子是分母与分子之和，分母是上一个分式的分子。
*/
# include <stdio.h>
int main()
{
	// n项求和
	int n;
	double sum = 0.0;
	double dividend; // 分子
	double divisor;  // 分母 
	int i;
	double t;		// 中间变量，用于暂时存储数据； 
	
	printf("输入求和的项数：");
	scanf("%d",&n); 
	// 分字分母初始化 
	dividend = 2;
	divisor = 1;
	for(i = 1;i<=n;i++){
		sum += dividend/divisor;
		t = dividend;
		dividend = dividend+divisor;
		divisor = t;
	} 
	printf("%f\n",sum);
	return 0;
 } 




// 2、1+ 1/2 + 1/3 +1/4…… 

# include <stdio.h>

int main()
{
	// n相求和
	// 1+ 1/2 + 1/3 +1/4…… 
	double i;
	int n;
	double sum = 0.0;
	printf("请输入求和项数："); 
	scanf("%d",&n);
	for(i = 1;i<=n;i++){
		sum += 1/i;
	} 
	printf("n相求和为：%f",sum);
	return 0;
 }

5、数据结构-稀疏数组

5、已知一个6*5稀疏矩阵如下所示，

（1）写出它的三元组线性表；

i 行标	j 列标	data 元素值
0	4	1
2	1	-1
3	4	-2
4	0	5
5	2	7

（2）给出三元组线性表的顺序存储表示。

// 三元组的结构体
typedef struct Triple{
	int data;   // 元素值 
	int i;      // 行号 
	int j;      // 列号 
}Triple; 

// 三元组线性表的顺序存储 
typedef struct TripleNode{
	int i;     // 行号 
	int j;     // 列号 
	int nums;  // 非零元素个数 
	Triple dataSum[MaxSize];  // 矩阵在三元组中的存储 
}TripleNode;

6、数据结构–二叉排序树

6、设有一个输入数据的序列是 { 46, 25, 78, 62, 12, 80 }, 试画出从空树起，逐个输入各个数据而生成的二叉搜索树。

7、数据结构-图生成树

7、对于图6所示的有向图若存储它采用邻接表，并且每个顶点邻接表中的边结点都是按照终点序号从小到大的次序链接的，

试写出：

(1) 从顶点①出发进行深度优先搜索所得到的深度优先生成树；

(2) 从顶点②出发进行广度优先搜索所得到的广度优先生成树；

8、数据结构–图

8、已知一个图的顶点集V和边集E分别为：

V={1,2,3,4,5,6,7};

E={<2,1>,❤️,2>,❤️,6>,<4,3>,<4,5>,<4,6>,<5,1>,<5,7>,<6,1>,<6,2>,<6,5>};

若存储它采用邻接表，并且每个顶点邻接表中的边结点都是按照终点序号从小到大的次序链接的，按主教材中介绍的拓朴排序算法进行排序，试给出得到的拓朴排序的序列。

9、算法阅读–质数+BFS

9.1 算法阅读 – 判断传入的数是不是质数

/*判断传入的数是不是质数*/
int Prime(int n)
{  
   int i=1;
   int x=(int) sqrt(n);
   while (++i<=x){
       if (n%i==0) break;
       if (i>x){
      		return 1;
  		}else{
      		return 0;
       }
   }
}

(1) 指出该算法的功能；判断传入的 n 是不是质数

(2) 该算法的时间复杂度是多少？ O(n^1/2)

9.2写出下述算法的功能：从初始点 i 开始出发，广度优先搜索由邻接表所表示的图

/*从初始点 i 开始出发，广度优先搜索由邻接表所表示的图*/
void AJ(adjlist GL, int i, int n)
{
	Queue Q;
	InitQueue(Q);
	cout<<i<<' ';
	visited[i]=true;
	QInsert(Q,i);
    while(!QueueEmpty(Q)) {
	      int k=QDelete(Q);  
		  edgenode* p=GL[k];  
		  while(p!=NULL){
		     int j=p->adjvex;  
			 if(!visited[j]){  
                 cout<<j<<' ';
				 visited[j]=true;
				 QInsert(Q,j);
			 }
			  p=p->next;  
		    }
	    }
}

10、算法填空–二分查找

10、算法填空（共8分）

// 如下为二分查找的非递归算法，试将其填写完整。

Int Binsch(ElemType A[ ],int n,KeyType K)

{

int low=0;

int high=n-1;

while (low<=high)

{

int mid=_________(low+high)/2_________；

if (K==A[mid].key)  return mid;    //查找成功，返回元素的下标

 	  else if (K<[mid].key) 

________high = mid -1_______;     //在左子表上继续查找

   	  else ______row = mid + 1_______;    //在右子表上继续查找

}

return -1;    //查找失败，返回-1

}

11、数据结构–删除头结点

编写算法（共8分）

HL是单链表的头指针，试写出删除头结点的算法。

ElemType DeleFront(LNode * & HL)

/*
解题思路： 设置一个p指针指向头结点的下一个结点，一个u指针表示待删除结点，
先将p赋值给u，p向后移，然后将HL指向新的头结点p 
*/ 

// 单链表结构定义 
typedef struct LNode{
	ELemType data;
	struct LNode *next;
}LNode,*LinkList;

// HL是头指针 
ELemType DeleFront(LNode *&HL){
	LNode *p = HL->next; // p指向头结点 
	LNode *u;     // 待删除结点 
	ElemType x;
	u = p;
	p = p->next;   // p 向后移 
	HL->next = p;  // HL指向新的头结点 
	x = u->data;
	free(u);
}