考研算法408,自命题可用（持续更新中...）

已于 2024-09-28 14:08:11 修改
阅读量1k 收藏 14
点赞数 12
文章标签： c语言 算法 考研 数据结构
于 2024-07-21 00:21:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42925518/article/details/140580056
版权

考研算法重的是思路，当你遇到不会的用暴力破解没问题，只要能表达清晰，可能一些细节没处理好，还有一起奇葩的案例实现不了，都没事，老师不会拿你代码去实现，也没有哪个时间。

注释很重要！！！

图片来源于网络，如有侵权必删除

如果对大家有用的话，麻烦大家点个赞和关注，这对我很重要！！！

数组

  1. 数组是存放在连续内存空间上的相同类型数据的集合。

  2. 数组下标都是从0开始的。

  3. 数组内存空间的地址是连续的

  4. 数组的元素是不能删的，只能覆盖。

数组最常用的算法有双指针，前缀和，滑动窗格等，我认为最重要的就是双指针了，我认为在数组题上挺好用的，而且后续的链表，还有一些排序查找也有空能用到。接下来我就进行介绍

双指针

从两端向中间迭代数组。

这时你可以使用双指针技巧：一个指针从头部开始，而另一个指针从尾部开始。

前后指针

在这里插入图片描述

逆置数组

在这里插入图片描述

快慢指针

同时有一个慢指针和一个快指针。

解决这类问题的关键是：确定两个指针的移动策略。

删除数组中值为2的数

在这里插入图片描述

小试牛刀——王道算法打卡表

01、顺序表删除最小值

从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。空出的位置由最后一个元素填补

int minVal(int* num, int n) {
	if(n<=0) return -9999;
	int index = 0;
	for (int i = 0; i < n; i++) {
		if (num[i] < num[index]) index = i;
	}
	int min = num[index];
	num[index] = num[n - 1];
	return min;
}


int main() {
	int num[] = { 9,2,4,5,7,8,6,1,3 };
	printf("%d", minVal(num,9));
}

02、顺序表的逆置

设计一个高效算法，将顺序表 L 的所有元素逆置，要求算法的空间复杂度为 0(1)

void inverse(int* nums,int n) {//利用前后指针算法
	int front = 0, last = n - 1;
	int temp = 0;//中间变量用于交换变量的时候暂存元素
	while (front<last)
	{
		temp = nums[front];
		nums[front++] = nums[last];
		nums[last--] = temp;
	}

}

int main() {
	int nums[] = { 1,2,3,4,5,6,7,8,9 };
	inverse(nums, 9);
	for (int i = 0; i < 9; i++) {
		printf("%d\t",nums[i]);
	}
}

03、删除顺序表中所有值为x的数据

对长度为 n 的顺序表编写一个时间复杂度为 O(n)、空间复杂度为 O(1) 的算法，该算法删除线性表中所有值为 x 的数据元素

int delect(int* nums, int n, int x) {
	int slow = 0, fast = 0;
	while (fast<n) {
		if (nums[fast] != x) {//将不为x的值，放到数组的前段，然后输出这段的长度
			nums[slow++] = nums[fast];
		}
		fast++;
	}
	return slow ;
}

int main() {
	int nums[] = { 1,2,2,3,2,4,5,6,7,8,9,2 };
	int n=delect(nums, 12, 2);
	for (int i = 0; i < n; i++) {
		printf("%d\t", nums[i]);
	}
}

04、删除下标i~j（i<=j）的所有元素

从给定顺序表 L 中删除下标 i~j（i<=j）的所有元素，假定 i，j 都是合法的

int delect(int* nums,int n, int i, int j) {
	int slow = i, fast = j+1;//直接将要删除的元素最后一位的后面序列往前覆盖
	while (fast<n) {
		nums[slow++] = nums[fast++];
	}
	return slow;

}

int main() {
	int nums[] = { 1,2,3,4,5,6,7,8,9,2 };
	int n=delect(nums,10, 3, 6);
	for (int i = 0; i < n; i++) {
		printf("%d\t", nums[i]);
	}
}

05、顺序表前后迁移

有个存放整数类型的顺序表 L，设计算法将 L 中所有小于等于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分

void sort(int* nums,int n) {
	int x = nums[0];
	int l = 1, f = n - 1;
	while (l <= f) {
		if (nums[l]>x && nums[f]<=x) {
			int temp = nums[l];
			nums[l] = nums[f];
			nums[f] = temp;
		}
		if (nums[l] <= x) {
			l++;
		}

		if (nums[f] > x) {
			f--;
		}
	}
	nums[0] = nums[f];
	nums[f] = x;
}

int main() {
	int nums[] = { 7,1,3,4,5,6,7,8,9,2 };
	sort(nums,10);
	for (int i = 0; i < 10; i++) {
		printf("%d\t", nums[i]);
	}
}

06、从有序顺序表中删除其值在给定值s与t之间的所有元素

从有序顺序表中删除其值在给定值 s 与 t 之间(要求 s<t)的所有元素，若 s 或 t 不合理或顺序表为空，则显示出错信息并退出运行

int delect(int* nums, int n, int s, int t) {
	if (s > t || n <= 0) return -1;
	int slow = 0, fast = 0;
	while (fast<n){
		if (nums[fast] >= s && nums[fast] <= t) fast++;
		else nums[slow++] = nums[fast++];
	}
	return slow;
}

int main() {
	int nums[] = { 1,2,3,4,5,6,7,8,9,2 };
	int n=delect(nums, 10, 3, 6);
	for (int i = 0; i < n; i++) {
		printf("%d\t", nums[i]);
	}
}

07、有序顺序表，删除重复的元素

从有序(升序)顺序表中删除所有其值重复的元素，使表中所有元素的值均不同

int delect(int* nums,int n) {//利用快慢指针
	int slow = 0, fast = 1;
	while (fast != n) {
		if (nums[slow] == nums[fast])fast++;//当遇到重复元素时，fast指针后移动
		else nums[++slow] = nums[fast++];//遇到不同元素时，将fast赋值给slow的后一位
	}
	return slow+1;
}

int main() {
	int nums[] = { 1,2,2,3,4,5,6,6,7,8,9 };
	int n=delect(nums,11);
	for (int i = 0; i < n; i++) {
		printf("%d\t",nums[i]);
	}
}

链表

  1. 链表是一种链式数据结构，由若干节点组成，每个节点包含指向下一节 点的指针。
  2. 链表的物理存储方式是随机存储，访问方式是顺序访问。
  3. 查找链表节点的时间复杂度是O(n)，中间插入、删除节点的时间复杂度是 O(1)。
  4. 链表是一种在物理上非连续、非顺序的数据结构
 typedef struct MyLinkedList{
    int data;
    struct MyLinkedList* next;
} MyLinkedList;

链表的介绍

插入

首先我们考虑在某个位置插入一个车厢：

我们首先把前一个车厢的挂钩指向我们新增的车厢，时间复杂度是常数。

后把新增车厢的挂钩指向后一个车厢，就完成了我们的插入操作。同样，这一步的时间复杂度也是常数。

08.gif

所以对于链表，我们可以在 O(1) 的时间内完成插入操作。

删除

接下来我们来考虑删除操作，显然我们可以通过直接将要删除车厢的前一个车厢的挂钩，直接指向其后一个车厢来实现删除操作。当然我们还需要注意释放这个要删除的车厢所占的内存。因此删除操作的时间复杂度也是常数级别。

08.2.gif

可以 在常数时间内 完成插入和删除是链表的最大优势，如果我们使用的是普通数组的话，是无法达到这样的速度的。

双向链表

刚才我们说一个车厢只能到达其后面的车厢，现在拓宽这个限制。现在的火车一般是存在两个火车头的，然后每一节车厢我们可以到达其前面和后面的车厢，这么修改以后，我们的链表就变成了 双向链表。

8.3.gif

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。
在这里插入图片描述

链表的实现（重要）

单链表的实现

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

typedef struct MyLinkedList{
    int data;
    struct MyLinkedList* next;
} MyLinkedList;

//初始化链表
MyLinkedList* myLinkedListCreate() {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=0;
    list->next=NULL;
    return list;
}

//获取指定位置的元素
int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList* list=obj;//定义指针，避免污染头指针
    if(index<0) return -1;
    while(index-->=0){//指针移动到index位置
        if(list->next==NULL) return -1;
        list=list->next;
    }
    return list->data;
}

//头插法
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));//定义新结点
    list->data=val;
    list->next=obj->next;//有头指针的插入
    obj->next=list;
}
//尾插法
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* pre=obj;
    while(pre->next!=NULL) pre=pre->next;//移动到链表尾
    pre->next=list;
}
//指定位置插入
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
     MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* pre=obj;
    while(index-->0){
        if(pre->next==NULL) return;//当移动到链表尾部的时候直接退出
        pre=pre->next;
    }
    list->next=pre->next;
    pre->next=list;
}

//指定位置删除
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    MyLinkedList* list=obj;
    if(index<0) return ;
     while(index-->0){ //移动到指定位置的前一个元素
         if(list->next==NULL) return;//当移动到链表尾部的时候直接退出
        list=list->next;
    }
    if(list->next==NULL) return;
    list->next=list->next->next;

}

void myLinkedListFree(MyLinkedList* obj) {
    free(obj);
}

双链表的实现

typedef struct MyLinkedList {
    int data;
    struct MyLinkedList* pre;
    struct MyLinkedList* next;
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=0;
    list->pre=NULL;
    list->next=NULL;
    return list;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
     MyLinkedList* list=obj;//定义指针，避免污染头指针
    if(index<0) return -1;
    while(index-->=0){//指针移动到index位置
        if(list->next==NULL) return -1;
        list=list->next;
    }
    return list->data;

}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
     MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));//定义新结点
    list->data=val;
    list->pre=obj;
    list->next=obj->next;//有头指针的插入
    if(obj->next!=NULL)obj->next->pre=list;
    obj->next=list;

}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* node=obj;
    while(node->next!=NULL) node=node->next;//移动到链表尾
    node->next=list;
    list->pre=node;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
     MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* node=obj;
    while(index-->0){
        if(node->next==NULL) return;//当移动到链表尾部的时候直接退出
        node=node->next;
    }
    list->next=node->next;
    list->pre=node;
    if(node->next!=NULL)node->next->pre=list;
    node->next=list;

}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
      MyLinkedList* list=obj;
    if(index<0) return ;
     while(index-->0){ //移动到指定位置的前一个元素
         if(list->next==NULL) return;//当移动到链表尾部的时候直接退出
        list=list->next;
    }
    if(list->next==NULL) return;
   if(list->next->next!=NULL) list->next->next->pre=list;
    list->next=list->next->next;

}

void myLinkedListFree(MyLinkedList* obj) {
    free(obj);
}

循环链表

typedef struct MyLinkedList{
    int data;
    struct MyLinkedList* next;
} MyLinkedList;

//初始化链表
MyLinkedList* myLinkedListCreate() {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=0;
    list->next=list;
    return list;
}

//获取指定位置的元素
int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList* list=obj;//定义指针，避免污染头指针
    if(index<0) return -1;
    while(index-->=0){//指针移动到index位置
        if(list->next==obj) return -1;
        list=list->next;
    }
    return list->data;
}

//头插法
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));//定义新结点
    list->data=val;
    list->next=obj->next;//有头指针的插入
    obj->next=list;
}
//尾插法
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* pre=obj;
    while(pre->next!=obj) pre=pre->next;//移动到链表尾
    pre->next=list;
    list->next=obj;
}
//指定位置插入
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
     MyLinkedList* list=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->data=val;
    list->next=NULL;
    MyLinkedList* pre=obj;
    while(index-->0){
        if(pre->next==obj) return;//当移动到链表尾部的时候直接退出
        pre=pre->next;
    }
    list->next=pre->next;
    pre->next=list;
}

//指定位置删除
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    MyLinkedList* list=obj;
    if(index<0) return ;
     while(index-->0){ //移动到指定位置的前一个元素
         if(list->next==obj) return;//当移动到链表尾部的时候直接退出
        list=list->next;
    }
    if(list->next==obj) return;
    list->next=list->next->next;

}

void myLinkedListFree(MyLinkedList* obj) {
    free(obj);
}

链表常考习题

删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    int index=0;//记录要删除元素正序的位置
    struct ListNode* fast=head;//快指针，用于指向要删除的结点
    struct ListNode* pre=(struct ListNode*)malloc(sizeof(struct ListNode));//定义一个头结点，避免原链表只有一个元素，删除后无法返回的情况
    pre->next=head;
    struct ListNode* slow=pre;//慢指针，指向要删除结点前的一个元素
    while(fast!=NULL){ //让快指针遍历到链表尾，记录链表长度
        fast=fast->next;
        index++;
    }
    index-=n;//保存正数的位置
    fast=head;
    while(index-->0){//让快慢指针移动要删除结点的位置，快——删除结点，慢——删除结点前一个结点
        fast=fast->next;
        slow=slow->next;
    }
    
    slow->next=fast->next;
    return pre->next;
}

2009年408真题——链表

假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效是算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data域的值，并返回1，否则，只返回0。

int kthToLast(struct ListNode* list, int k){
    struct ListNode* fast=list;
    struct ListNode* slow=list;
    while(k-->0) fast=fast->next;
    while(fast!=NULL){
        fast=fast->next;
        slow=slow->next;
    }
    if(slow!=list){
    	printf("%d",slow->val);
    	return 1;
    }
     else return 0;
}

2010年408真题——顺序表

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

暴力破解：利用辅助空间

void move(int* nums, int n,int p) {
	if (p<0|| p>n) return;
	int* res = (int*)malloc(sizeof(int) *p);//辅助空间存储，用于存储0~p-1元素
	for (int i = 0; i < p;i++) {
		res[i] = nums[i];
	}
	for (int f = p,i=0; f < n; f++,i++) {//将p~n个元素前移
		nums[i] = nums[f];
	}
	for (int i = n - p, j = 0; j < p; i++, j++) {//将辅助空间存储的元素存储到，p移动完后的位置
		nums[i] = res[j];
	}
}
int main() {
	int nums[] = { 1,2,3,4,5,6,7,8,9,0 };
	move(nums, 10, 2);
	for (int i = 0; i < 10; i++) {
		printf("%d\t", nums[i]);
	}
}
    
}

优化：利用三次反转
假设我们有数组R = [1, 2, 3, 4, 5, 6, 7] 并且 p = 4，我们希望将数组循环左移4个位置。
原始数组：R = [1, 2, 3, 4, 5, 6, 7]
第一步反转整个数组：R = [7, 6, 5, 4, 3, 2, 1]
第二步反转前p个元素：R = [5, 6, 7, 4, 3, 2, 1]
第三步反转剩余的元素：R = [5, 6, 7, 1, 2, 3, 4]

   
// 反转数组中指定区间的元素  
void reverse(int arr[], int start, int end) {  
    while (start < end) {  
        int temp = arr[start];  
        arr[start++] = arr[end];  
        arr[end--] = temp;  
    }  
}  
  
// 将数组循环左移p个位置  
void rotateLeft(int arr[], int n, int p) {  
    // 如果p大于等于n，则取模以避免不必要的移动  
    p = p % n;  
    if (p == 0) return; // 如果p为0，则无需移动  
  
    // 第一步：反转整个数组  
    reverse(arr, 0, n - 1);  
    // 第二步：反转前p个元素  
    reverse(arr, 0, p - 1);  
    // 第三步：反转剩余的元素  
    reverse(arr, p, n - 1);  
}

2011年408真题——顺序表

求两升序序列的中位数：一个长度为L(L>1)的升序序列S，处在第[L/2]个位置的数称为S的中位数。

例如,若序列S=(11,13,15,17,19)，则S, 的中位数是 15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S=(2.4.6.8.20)，则S和S2 的中位数是 11。

现有两个等长升序序列 A和 B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

暴力破解：利用辅助空间

int medianSearch(int* S1, int* S2, int Size) {
    int l=0,f=0;//l表示S1数值指针，f表示S2数组指针
    int i=0;
    int* nums=(int*)malloc(sizeof(int)*(Size*2));//定义一个新的数组
    
    while(l<Size&&f<Size){//排序插入新数组
        if(S1[l]<=S2[f]) nums[i]=S1[l++];
        else nums[i]=S2[f++];
        i++;
    }
    while(l!=Size)nums[i++]=S1[l++];//s1没遍历完，就将其全部放入新数组中
    while(f!=Size)nums[i++]=S2[f++];
    
    return nums[(i-1)/2];//输出中位数
    
}

2013年408真题——顺序表

已知一个整数序列 A=(a0,a1,…,an-1)，其中 0≤ai<n(0<i<n)。若存在 ap1= ap2=…=apm=x且m>n/2(0<pk<n,l≤k<m)，则称x为A的主元素。例如A=(0,5,5.3,5,7.5.5)，则5为主元素;又如A=(0,5,5,3.5.1.5.7)，则A中没有主元素。
假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素;否则输出-1。
主元素的定义是它在数组中出现的次数超过数组长度的一半！！！

int total(int* nums,int n) {
	int count = 0, totalNum = 0;//count统计次数，totalNum用于存储主元素
	for (int i = 0; i < n; i++) {//找出主元素
		if (count == 0) {//当count=0，开始记录主元
			totalNum = nums[i];
			count++;
		}
		else if (totalNum == nums[i]) count++;//遇到主元次数加+1
		else count--;//不是主元，count--，主元的个数>n/2，所以遍历完整个数组个数是>1
	}

	count = 0;
	for (int i = 0; i < n; i++)//验证是否是主元
		if (totalNum == nums[i])count++;

	return count > n / 2 ? totalNum : -1;
	
}
int main() {
	int nums[] = {0,5,5,3,5,5,5,7};
	printf("%d\n",total(nums, 8));
}

2018年408真题——顺序表

给定一个含 n(n>1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5,3,2,3}中未出现的最小正整数是 1;数组{1,2,3}中未出现的最小正整数是 4。
暴力： 快排+hash表+快慢指针
注：qsort()要背下来!!!

int cmp(const void* a, const void* b) {
	return *(int*)a - *(int*)b;//升序
	//	return *(int *)b - *(int *)a;//降序
}
int firstNum(int* nums, int n) {
	//对数组进行快排,让数组变得有序
	qsort(nums, n, sizeof(nums[0]), cmp);//qsort(数组首地址，数组长度，数组数据元素的大小，比较函数)
	
	
	int k = 0;//用于记录数组第一个元素的下标
	for (int i = 0; i < n; i++) {
		if (nums[i] < 0)k++;
	}
	if (k == n) return 1;//如果全是负数返回1
	int length = n-k;//记录非负正数个数
	int* hash = (int*)malloc(sizeof(int) * (length));//定义索引数组(1~k)，用于判断缺少哪个元素
	for (int i = 0; i < length; i++) hash[i] = i + 1;
	
	int l = 0, f = k;//定义快慢指针
	while (f < length) {//当代表nums的快指针移动到数组尾部时，表示缺少hash的该元素
		if (nums[f] == nums[l])l++;//当数组中有索引表的值的时候，索引表指针后移动
		f++;
	}
	return l==length?length:hash[l];
}

int main() {
	int nums[] = {1,3,2,3};
	printf("%d\n",firstNum(nums, 4));

}

优化： hashMap

int firstNum(int* nums, int n) {
	//伪HashMap容器，利用下标当作hash索引表，元素当作value值
	int* hashMap = (int*)malloc(sizeof(int) * (n+1));//定义索引数组(1~k)，用于判断缺少哪个元素
	int i = 0;
	for ( i = 1; i <=n; i++) hashMap[i] = 0;//初始化hashMap
	
	for ( i = 0; i < n; i++) {//统计元素nums出现的元素
		if (nums[i] > 0) {
			hashMap[nums[i]]=1;
		}
	}
	for ( i = 1; i <= n; i++) {//遇到没出现的元素就退出了
		if (hashMap[i] == 0) break;
	}
	return i;

}

int main() {
	int nums[] = {-5,3,2,3};
	
	printf("%d\n",firstNum(nums, 4));
	/*for (int i = 0; i < n; i++) {
		printf("%d\t", nums[i]);
	}*/
}

2020年408真题——顺序表

定义三元组(a,b,c)(a,b,c均为整数)的距离D=|a-b|+|b-c|+|c-a|。给定3个非空整数集合S1、S2和S3，按升序分别存储在3个数组中。
请设计一个尽可能高效的算法，计算并输出所有可能的三元组(a,b,c)(a⋿S1，b⋿S2，c⋿S3)中的最小距离。例如 S1={-1,0,9},S2={25,-10,10,11},S3={2,9,17,30,41},则最小距离为 2，相应的三元组为(9,10,9)。
暴力破解：穷举法

int Triple(int* S1,int n1,int* S2,int n2,int* S3,int n3 ) {
	int min = 9999;
	for (int a = 0; a < n1; a++) {//将每一个元素都进行运算
		for (int b = 0; b < n2; b++) {
			for (int c= 0; c < n3; c++) {
				int val =abs(S1[a]-S2[b])+ abs(S2[b] - S3[c])+ abs(S3[c]-S1[a]);
				min=min > val ? val : min;
			}
		}
	}
	return min;
}

int main() {
	int S1[3] = {-1,0,9};
	int S2[4] = { 25,-10,10,11 };
	int S3[5] = { 2,9,17,30,41 };
	printf("%d\n", Triple(S1, 3,S2,4,S3,5));
}
C语言考研机试(自用)
weixin_54262350的博客
03-20 2502
现在要移走一些树，移走的树的区间用一对数字表示，如 100 200表示移走从100到200之间（包括端点）所有的树。题目: 有一个长度为整数L(1
操作系统基础填空 用于攻克自主命题填空部分（试卷摘录）
weixin_48122802的博客
03-10 1375
摘录于各高校期末考试题目
【考研】408算法题暴力简易考场版
可乐大牛的博客
04-28 7080
文章目录2.2.3.10算法思想算法流程算法实现完整代码2.2.3.11算法思想算法流程算法实现完整代码2.2.3.12算法思想算法流程算法实现完整代码2.2.3.13算法思想算法流程算法实现完整代码1算法思想算法流程算法实现完整代码1算法思想算法流程算法实现完整代码1算法思想算法流程算法实现完整代码 王道数据结构2022版本 2.2.3.10 算法思想 创建辅助数组s，先将R数组中前p个元素放入辅助数组s，再将R后n-p个元素左移p(0<p<n)个位置，然后将s中暂存的p个元素放到R数组的后
数据结构与算法：408考研算法经典题目大总结（不断更新）
weixin_50690285的博客
08-24 1万+
1. 合并两个有序顺序表为一个有序顺序表。2. 删除有序顺序表中所有值重复的元素。3. 顺序表中删除给定值之间的元素。1. 删除线性表中所有值为x的元素。一. 线性表——顺序表部分。
贼全面的计算机考研数据结构算法题集合（408+自命题均可）
克克克克业业的学习记录
07-15 9152
一篇很全面的题集合！按考研大纲顺序排列，题源leetcode！
C 408—《数据结构》算法题基础篇—链表（下）
最新发布
Cyan_RA9的博客
10-15 1498
408考研——《数据结构》算法题基础篇之链表（下）。
2018年的专业408算法题
韩江雪de 小屋
12-18 2100
文章目录0 结果1 题目2 思路3 实现 0 结果 1 题目 2 思路 因为时间高效，则采用空间换时间的方法。 方法：打表计数【数组大小设为n，即元素的个数】。 遍历数组出现number,如果范围在[1,n]之间，则记[number-1]次数为1，遍历完数组后，指标i从[0,n)开始递增判断表值是否为0，是则跳出循环,最后输出i+1。 3 实现 #include <cstdio> #include <cstdlib> int Func(int A[], int n){
2021年武汉科技大学硕士研究生招生考试初试自命题试题：冶金传输原理-A卷.pdf
04-25
根据给定文件的信息，我们可以提炼出以下相关的IT知识点（这里主要指代的是计算机科学与技术领域内关于数据处理、信息存储、算法应用等方面的知识点）。虽然原文件与IT行业关联不大，但我们可以从数据结构、算法分析...
北京交通大学925数据结构2021年初试大纲.pdf
03-11
**应用场景**：在多任务操作系统中，为防止多个进程竞争有限资源导致死锁现象，通常会采用银行家算法或死锁检测算法来预防或解决死锁问题。 **二、存储管理** 1. **程序处理与内存管理**： - **分区存储管理**：...
电子科技大学信号与系统（858）2014-2019真题.pdf
09-15
《电子科技大学信号与系统（858）2014-2019真题...总结，电子科技大学858信号与系统考研真题资料涵盖了信号与系统的主要知识点，考生应以此为参考，全面复习，加强理解和应用，以期在研究生入学考试中取得优异成绩。
考研408 王道 数据结构 算法题整理（一）数组
nabobess的博客
03-09 720
考研408 王道 数据结构 算法题整理（一）数组
【408】C语言：构造类型-数组
weixin_63983205的博客
07-07 576
还得是pdf不会乱。学习笔记自用数据类型--构造类型（数组、结构体）
2020考研数据结构 408算法2011年真题
lovegramer的博客
03-26 2894
问题： 一个长度为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的中位数。要...
2020年408考研算法题
Shaun善逸的博客
06-30 2330
题目 定义三元组 (a,b,c) 的距离 D=|a-b|+|b-c|+|c-a|。给定3个非空整数集合S1，S2，S3，按升序分别存储在3个数组中。请设计一个尽可能高效的算法，计算并输出所有可能的三元组 (a,b,c) 中的最小距离。例如S1={-1,0,9}, S2={-25,-10,10,11}, S3={2,9,17,30,41}。则最小距离为2，相应的三元组为 (9,10,9) 题解 暴力法，三层for循环 代码 ...
2018年408考研算法题
Shaun善逸的博客
06-22 914
题目 给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。 题解 分析 遍历A数组，利用辅助动态数组，类似之前提到过的，元素值作为数组下标。第一个为0的值即是所求的最小正整数。 代码 int findmin(int A[], int n){ int *B = (int *)malloc(sizeof(int) * n); for(int i=0;i<
2018考研计算机408经验详谈
热门推荐
Phoenix
03-22 16万+
2018浙大计算机考研经验总述 2018考研数学经验详谈 考研408经验详谈 备考时间：2017.03.10 基础情况：数据结构，计组，操作系统，网络水过。。。基础约为零。。。 实考成绩：133 前言：408备考最讲求“反复多次与全面”，这句话在王道单科书-《操作系统复习指导》中出现了三次，可见这句话对于复习408而言是十分重要的，我也在复习过程中对这句话十分有感触，量变总会产生...
2019年考研计算机统考408真题算法题
zhaoxk88的博客
06-02 2423
题目如图所示 算法思想：首先将链表从中间断开，分成前后两个小链表，再将后链表逆置，然后插入到前链表中。 具体代码如下 #include<stdio.h> #include<stdlib.h> typedef struct DNode { int data; struct DNode* next; }Node,*Link; void Create(Link& link) { link = (Link)malloc(sizeof(Node)
计算机考研408的算法题详解
qq_41148224的博客
05-22 9618
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、创建动态数组： 在堆中
2019年计算机考研408真题
HWP
11-06 2万+
如图： 复习真题以及资料下载渠道
考研必备：数据结构与算法学习资料.zip
这些算法都是数据结构和算法课程中的核心内容，对于考研学生来说，掌握这些算法能够帮助他们在算法面试中脱颖而出，同时也是计算机科学领域内的基础技能。中公和海文作为知名的考研培训机构，提供的这一系列PPT资料...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值