计算机考研自命题(7)

1、C语言–最大公约数

1、求两个数的最大公约数，分别用递归和非递归方法。（往年考题有）

# include<stdio.h>

/*
解题思路：
最大公约数指的是两个或多个整数共有约数中最大的一个
采用的是欧几里得算法，也叫辗转相除法：就是将 a,b两个数取余数假设 t = a%b，然后将较小的元素 b 对t再取余数，直到最后余数为0,则最后依次取余数的 b就是最大公约数
*/
 
// 求两个数的最大公约数
// 方法1 递归

int GCB(int x,int y){
	if(y>0){
		return GCB(y,x%y);
	}else{
		return x;
	}
} 

// 方法二 非递归

int gcb(int x,int y){
	int t ;
	while(y!=0){
		t = x%y;
		x = y;
		y = t;
	}
	return x;
} 

 
int main (){
	int x = 18,y = 16;
	int re1 = GCB(x,y);
	int re2 = gcb(x,y);
	printf("re1 = %d\n",re1);
	printf("re2 = %d\n",re2);
	return 0;
} 

2、背包装载问题

背包装载问题，要求设计一个算法，把把重量为 S1, S2, S3........Sn 的货物装入最大重量限度为 M 的背包，要求尽可能装的多，如果装载

有问题就输出 无解 ，如果成功就输出装载的结果（至于是输出装载的总重量还是装载的货物数量题目没说）

此题解法为：把S1，S2.........Sn 从大到小排序，然后不断挑选能装入的最大重量的某个货物装入，直到装不下即可，无解的情况对应最小质

量也大于M，就会导致无解

3、C语言–文件

3、文件类型题目，文件 “data.txt” 中有N个整数，要求全部读出后把所有数的和存到文件末尾注：文件写整数的方法有：

fprintf( fp，“%i” , a) 或者 fwrite(a, sizeof(int), 1, fp) 指导书中不推荐使用前者

/*
解题思路：首先打开文件，利用fscanf()函数从文件中读入一个元素进行求和，feof()函数判断是否到达文件尾，然后将所有元素的和
用fprintf()函数从新写回文件中
*/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main(){
    int number, sum = 0;
    FILE *fp1;
    fp1 = fopen("data.txt", "r+");
    if (fp1 == NULL) {
        printf("Open file error.\n");
        exit(0);
    }

    fscanf(fp1, "%d", &number);       // 从文件中读入一个数字
    while (!feof(fp1)) {             // 是否读取到文件尾 
        sum += number;
        fscanf(fp1, "%d", &number);  // 求和
    }
    
    fprintf(fp1, "%d\n", sum);		// 将文件中读取出来的数据和从新写入文件尾 
    fclose(fp1); 
    return 0;
    
}

4、数据结构–图

4、给出一个图，要求写出他的拓扑排序，写出两点的简单路径 (此题较为简单，只需去王道书里找个拓扑的题做一次弄明白了就可

以解决)

1. 求图的拓扑排序

2. 求图中全部强连通分量

3. 求V1到V5的简单路径

5、数据结构–构造二叉树

5、根据不完整的前序中序后序遍历序列构造二叉树（题目给出了一颗树带空缺的前序后续和中序排列，要求还原空缺）最终画出

树的形态。例如：前序：1 ** 2，中序：2 1 ** ，后序：2 ** 1 要求还原空缺并画出树的样子

6、数据结构-查找

6、查找：给出了一组数A1, A2…An 1.用最快的速度在数据中查找x；2.若x存在则将x与其后元素互换位置；3.若不存在x，

则插入x。(此题为一个模拟折半插入排序的题)

/*线性表中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其于后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序*/

/*
解题思路：线性表中存放有一组数据
然后用二分查找法，看表中是否有值为 x 的元素，如果有，则交换x和他后一个元素，如果x是最后一个元素则不用交换
，如果没有将x 添加到指定的位置
*/

// 线性表结构定义
typedef struct SqList{
    int data[100];
    int length;
}SqList;

// 折半查找 并添加 
void Binary_search(SqList2 &L,int x){ //
	int low,high = L.length-1,mid;
	while(low<=high){
		mid = (low+high)/2;
		if(L.data[mid] == x){
			//  找到元素，和后面的元素交换 
			break;
		}else if(L.data[mid] < x){
			low = mid +1;
		}else{
			high = mid - 1;
		}
	}
	
	if(L.data[mid] == x&&mid != L.length-1){  // 找到该元素，
		int t = L.data[mid]	;					//并且该元素不是最后一个位置就和后一个元素交换 
		L.data[mid] = L.data[mid+1];
		L.data[mid+1] = t;
	} 
	
	// 如果没找到就在指定位置添加该元素
	if(low>high){
		int i=0;
		for(i = L.length-1;i>high;i--){
			//元素后移;
			L.data[i+1]=L.data[i]; 
		}
		// 添加 x到指定位置，长度加1 
		L.data[i+1] = x;
		L.length++;
	} 
} 

7、数据结构–单循环链表合并

7、有两个单循环链表的头结点L1和L2，其长度分别为m和n，使用时间复杂度较好的算法将其合并成一个带有头结点的单循环链表。

/*
解题思路：首先遍历两条，分别找到L1 和 L2 链表的尾结点，然后将L1的尾结点指向L2的头结点，将L2的尾结点指向L1的头节点
*/
// 单循环链表的结构体定义
typedef struct LNode{
    int data;
    struct LNode *next;
    struct LNode *pre;
}LNode,*LinkList;

LinkList link(LinkList &L1,LinkList &L2)){
	LNode *p = L1;
    LNode *q = L2;
    while(p->next != L1){ // 找到 L1的尾结点
        p = p->next;
    }
    while(q->next != L2){ // 找到L2的尾结点
        q = q->next;
    }
    q->next = L1;     // L2的尾结点指向L1的头节点
    p->next = L2;     // L1的尾结点指向L2的头结点
    return L1;
}

8、数据结构–哈希表

8、有9个数（23，31，45，120，132，100，95，67，85），要求自己设置一个合理的hash函数，并采用链式存储的方式解决

冲突，并计算ASL成功和失败的数值

9、数据结构-- 交换左右子树

9、非递归方式交换二叉树的左右子树

typedef struct BiNode{
	char data;
	struct BiNode *lchild,*rchild;
}BiNode,*BiTree;

//1、递归 利用先序遍历
void exchange(BiTree &T){
	if(T){
		BiNode *temp;
		temp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = temp;
		exchange(T->lchild);
		exchange(T->lchild);
	}
} 

/*
解题思路：递归思想
可以利用先序遍历改造，
首先将根节点入栈，如果栈不为空，则将栈顶元出栈，然后交换栈顶元素的左右孩子
然后再对左子树进行交换之后再对右子树进行交换
*/

 
// 2、非递归交换左右子树 ,以用先序遍历 
void BiTreeChangeStack(BiTree &T){
	BiNode *p,*temp;
	Stack  s;    	// 初始化一个栈
	Initstack(s); 
	if(T){
		s.push(T);  // 将根节点入栈 
	}
	while(!s.empty()) {	// 如果栈中不为空
		p = s.pop() ;	// 弹出栈顶元素
		temp = p->lchild; // 将左右子树交换
		p->lchild = p->rchild;
		p->rchild = temp; 
		
		if(p->lchild !=NULL){
			s.push(p->lchild);
		}
		if(p->rchild !=NULL){
			s.push(p->rchild);
		} 
	}
}