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;
}
}