计算机考研408的算法题详解

2019年真题

题目：设线性表L=（a1，a2，a3,......,a(n-2)，a(n-1)，a(n)），采用带头结点的单链表保存，链表中的结点定义如下。请设计一个空间复杂度为O(1)且时间上尽可能高效的算法，重新排列L中的各结点，得到新线性表L'=（a1，a(n)，a2，a(n-1)，a3，a(n-2),......）。

typedef struct node {
    int data;
    struct node *next;
} NODE;

 思路分析：①先找到链表的中心结点，使用两个指针p，每次p走一步，q走两步，当q到链表尾时，p正好在链表中心结点。②将链表后半段原地逆置。③将单链表前后两段中依次各取一个结点，进行重排。

NODE *reverseList(NODE *head) {
	//将指针全部反转 
	NODE* pre = NULL;
	NODE* cur = head;
	NODE* tmp = NULL;//记录cur的下一个结点
	while(cur != NULL) {
		//记录当前节点的下一个节点
		tmp = cur->next;
		//然后将当前节点指向pre
		cur->next = pre;
		//pre和cur节点都前进一位
		pre = cur;
		cur = tmp;
	}
	return pre;
} 

void changeList(NODE *head) {
	NODE *p, *q, *temp;
	p = q = head;
	//1、找到中间结点 
	while(q->next != NULL) {
		p = p->next;
		q = q->next;
		if(q->next != NULL) {//q走两步。用if再判断一次是为了防止走一步后就已到队尾，出现NULL->next异常 
			q = q->next;
		}
	} 
	//此时p指向链表L的中心结点 n/2，向下取整。 
	//2、后半段链表反转。 
	NODE *back = reverseList(p-next);//将后半段链表逆置，back指向后半段链表的第一个节点。 
	NODE *pre = head->next;   //pre指向前半段链表的第一个节点。 
	//3、前半段链表和后半段链表依次各取一个结点。 
	while(e != NULL) {
		temp = back->next;//用于back指针后移
		back->next = pre->next;
		pre->next = back;
		pre = back->next;//pre指针后移 
		back = temp; //back指针后移 
	}
}

链表的算法题一定要手动模拟一遍。其中链表反转部分参考力扣：https://leetcode-cn.com/problems/reverse-linked-list/solution/dong-hua-yan-shi-206-fan-zhuan-lian-biao-by-user74/

 

2018年真题

题目：给定一个含n（n>=1）个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5,3,2,3}中未出现的最小正整数是1；数组{1,2,3}中未出现的最小正整数是4。

思路分析：基于map的思想，创建一个和数组等长的map<int,int>，遍历数组，对map[i]++；再遍历一次map，对第一次出现的map[i]!=0时的键i输出，即为最小正整数。但408不让用STL，因此用数组来代替map。

1、创建动态数组：

在堆中开辟一块大小为n*sizeof(int)的一块内存空间（因为int是32位，因而此处开辟了n*4Bit的存储空间）；

指针B指向这块内存空间的起始地址（即数组的第一个元素）；

malloc前面的（int*）用于强制类型转换，表示这块空间用来存储int型数组。

int *B = (int *)malloc(n*sizeof(int));
free(B);

void* malloc(size_t size);
//其中参数size_t size表示动态内存分配空间的大小，以字节为单位。malloc返回值是一个指针。

void  free(void *ptr);
//当不在使用malloc()函数申请的空间之后，应释放掉这个内存空间：

2、批量赋初值：对数组B中的n个元素均赋值为0。

memset(B,0,n*sizeof(int));

void *memset(void *s, int v, size_t n);  
//这里s可以是数组名，也可以是指向某一内在空间的指针；
//v为要填充的值；
//n为要填充的字节数； 

完整代码：

#include <iostream>
#include <string.h>
using namespace std;

/*数组中未出现的最小正整数*/

int findMissMin(int A[], int n){
	int *B = (int *)malloc(n*sizeof(int)); //创建动态数组并分配存储空间
	memset(B,0,n*sizeof(int)); //赋初值
	int i;
	for(i = 0; i < n; ++i) {
		if(A[i] > 0 && A[i] < n){// 仅对数组A中的值为1~n的元素进行处理
			B[ A[i]- 1 ]++;
		}
	}
	for(i = 0; i < n; ++i) {
		if(B[i] == 0){
			break;
		}
	}
        free(B);
	return i + 1;
}

int main(){
	int a[3] = {1,2,3}, c[4] = {-5,3,2,3};
	cout<<"{1,2,3}中未出现的最小正整数："<<findMissMin(a, 3)<<endl;
        cout<<"{-5,3,2,3}中未出现的最小正整数："<<findMissMin(c, 4)<<endl;
	return 0;
} 

2010年真题（顺序表）（循环左移p位）

设将n(n>1)个整数存放到一维数组R中，设计一个在时间和空间方面都尽可能高效的算法。将R中的序列循环左移p (0<p<n) 个位置，即将R中的数据由{Xo，X, …， Xn-1}变换为{Xp，Xp+1, … Xn-1, X0，X1, …，Xp-1}。

思路分析：用a表示数组的前p个元素，用b表示余下的(n-p)个元素。本题将数组ab转换为ba，则考虑对a、b分别逆置后，在对整体逆置，即可得到循环左移后的序列。(类似线代的可逆矩阵）

#include <iostream>
using namespace std;
#define n 10 //数组最大长度为10

void Reverse(int R[], int l, int r){
	int i, j, temp;
	for(i = l, j = r; i < j; ++i, --j){
		temp = R[i];
		R[i] = R[j];
		R[j] = temp;
	}
}

int main()
{
	int p = 7;  //循环左移7位 
	int *R = (int *)malloc(sizeof(int) * n);
	for(int i = 0; i < n; ++i){
		R[i] = i + 1;
	} 
	Reverse(R, 0, p-1); //    前p位逆序为：7 6 5 4 3 2 1 
	Reverse(R, p, n-1); //余下n-p位逆序为：              10 9 8
	Reverse(R, 0, n-1);//      整体逆序为：8 9 10 1 2 3 4 5 6 7 
	for(int i = 0; i < n; ++i){
		cout<<R[i]<<" ";
	} 
	return 0;	
} 

效率分析：时间复杂度在于Reverse函数，为O(n)，空间复杂度O(1) 。

2011年真题（顺序表）（升序序列取中值）

一个长度为L（L>=1）的升序序列S,处在第[L/2]个位置的数称为S的中位数。例如，若序列S1=(11,13,15,17,19)，则S1的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2,4,6,8,20)，则S1和S2的中位数为11。现在有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

思路分析：考虑归并排序中merge函数的思想，从两个升序序列的首部通过比较依次取出较小值，取出的第L个数即为整体中值。本方法的时间复杂度为O(n)，但胜在思路与代码简单，另还有较复杂的优化的O(logn)方法。

#include <iostream>
using namespace std;
#define n 3

int findMid(int A[], int B[], int L){
	int i = 0, j = 0; 
	int mid;
	while(i + j < L){//当i+j=L时跳出循环，取中值 
		if(A[i] < B[j]) {mid = A[i++];}
		else {mid = B[j++];}
	}
	return mid;
}

int main()
{
	int A[n] = {1, 3, 5};
	int B[n] = {2, 4, 6};
	cout<<findMid(A,B,n);
	return 0;	
} 

 

2009年真题（单链表）（查找倒数第k个数）

typedef struct node{/*结点类型定义*/
	ElemType data;/*结点的数据域*/
	struct node *next;/*结点的指针域*/
}LNode,*LinkList;

int Search_K(LinkList L, ElemType k)
{	//查找倒数第k个结点 
	LNode *p = L->next;
	LNode *q = L->next;
	while(p != NULL) {
		if(k > 0) k--;//p先行走k步 
		else q = q->next;
		p = p->next;
	}
	if(k > 0){//p遍历完了k仍为减到0，查找失败 
		return 0;
	}else{
		cout<<q->data<<endl;
		return 1; 
	}
}