2021王道数据结构——线性表课后大题_1

已于 2022-11-30 16:52:12 修改
阅读量640 收藏 2
点赞数 3
分类专栏： 算法 文章标签： 数据结构
于 2020-10-29 20:01:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruvikm/article/details/109367309
版权

线性表的顺序表示课后大题——P19–P21
有几个必须掌握的算法

  1. 归并排序
    P19.7
    P20.11
  2. 用空间换时间——有n个元素就开一个大小为n的数组
    P20.12
    P21.13
  3. 离散数学中的矩阵的预算规则
    P19.8
    P20.10

全部代码如下，代码中已给出题目

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

#define MAX 30
#define _for(i,a,b) for( int i=(a); i<(b); ++i)
#define _rep(i,a,b) for( int i=(a); i<=(b); ++i)

typedef struct {
	int data[MAX];
	int length;
}List;

void swap(int* a, int* b) {
	int t;
	t = *a;
	*a = *b;
	*b = t;
}

//给定一个List，传入List的大小，要逆转的起始位置
void Reserve(List* list, int start, int end, int size) {
	if (end <= start || end >= size) {
		return;
	}
	int mid = (start + end) / 2;
	_rep(i, 0, mid - start) {
		swap(&list->data[start + i], &list->data[end - i]);
	}
	/*  _for(i, 0, list->length) {
		  printf("%d ", list->data[i]);
	  }*/
}

//P19.1
//从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。空出的位
//置由最后一个元素填补, 若顺序表为空则显示出错信息并退出运行
int FindMin(List* list)
{
	if (!(*list).length) {
		printf("Error!\n");
		return -1;
	}

	int Min = 9999;
	int point;
	for (int i = 0; i < (*list).length; i++)
	{
		if ((*list).data[i] < Min)
		{
			Min = (*list).data[i];
			point = i;
		}
	}
	(*list).data[point] = (*list).data[(*list).length - 1];
	(*list).length -= 1;
	return Min;
}

//P19.2
//设计一个高效算法，将顺序表的所有元素逆置，要求算法的空间复杂度为O⑴
void reverse(List* list) {
	if (!list->length)
		return;
	for (int i = 0; i < (*list).length / 2; i++) {
		swap(&(list->data[i]), &(list->data[list->length - i - 1]));
	}
}

//P19.3
//对长度为n的顺序表L, 编写一个时间复杂度为O(m)空间复杂度为O(1)的算法,
//该算法删除线性表中所有值为x的数据元素
void DeleteX(List* list, int X) {
	for (int i = 0; i < (*list).length; i++) {
		if ((*list).data[i] == X) {
			for (int j = i + 1; j < (*list).length; j++) {
				(*list).data[j - 1] = (*list).data[j];
			}
			(*list).length -= 1;
			break;
		}
	}
}

//P19.4
//从有序顺序表中删除其值在给定值s与t之间(要求s < t)的所有元素, 如果s或t不合
//理或顺序表为空, 则显示出错信息并退出运行
void OrderlyDelete(List* list, int X, int T) {
	int i = 0, j = 0;
	for (i; i < (*list).length; i++)
		if ((*list).data[i] >= X)
			break;

	for (j; j < (*list).length; j++) {
		if ((*list).data[j] > T)
			break;
	}
	int len = j - 1;
	for (i; i < (*list).length; i++, j++) {
		list->data[i] = list->data[j];
	}
	list->length -= len;
}

//P19.5
//从顺序表中删除其值在给定值s与t之间(包含s和t, 要求s < t)的所有元素,
//如果s或t不合理或顺序表为空, 则显示出错信息并退出运行
void DeleteS_T(List* list, int S, int T) {
	if (S >= T || !list->length)
		return;

	for (int i = 0; i < (*list).length; i++) {
		if ((*list).data[i] >= S && (*list).data[i] <= T) {
			for (int j = i + 1; j < (*list).length; j++) {
				(*list).data[j - 1] = (*list).data[j];
			}
			//要重新回退一个位置，重新检测，否则会跳过某些数字
			if (i)
				i -= 1;
			(*list).length -= 1;
		}
	}
}

//P19.6
//从有序顺序表中删除所有其值重复的元素,使表中所有元素的值均不同

void OlderlyDeleteSame(List* list) {
	for (int i = 0; i < list->length; i++) {
		if (list->data[i + 1] == list->data[i]) {
			for (int j = i + 1; j < list->length; j++) {
				list->data[j] = list->data[j + 1];
			}
			list->length -= 1;
			if (i)
				i -= 1;
		}
	}
}

//P19.7
//将两个有序顺序表合并为一个新的有序顺序表, 并由函数返回结果顺序表

List MergeList(List A, List B) {
	int i = 0, j = 0;
	List C;
	int k = 0;
	while (i < A.length && j < B.length) {
		if (A.data[i] >= B.data[j]) {
			C.data[k++] = B.data[j++];
		}
		else {
			C.data[k++] = A.data[i++];
		}
	}
	while (i < A.length) {
		C.data[k++] = A.data[i++];
	}
	while (j < B.length) {
		C.data[k++] = B.data[j++];
	}
	C.length = k;
	return C;
}

//P19.8
//已知在一维数组A[m + n]中依次存放两个线性表(a1, a2, a3…, am)和(b, b2, b3, …, bn)。试编
//写一个函数, 将数组中两个顺序表的位置互换, 即将(b1,b2,b3,…, bn)放在(a1，a2, a3, …, am)的前面

void swaplist(List* A, int m, int n, int size) {
	Reserve(A, 0, m + n - 1, size);
	Reserve(A, 0, n - 1, size);
	Reserve(A, n, m + n - 1, size);
}

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

//我的方法 大力出奇迹
void CheckAndSwap(List* A, int x) {
	bool flag = true;
	_for(i, 0, A->length) {
		if (A->data[i] == x) {
			swap(&A->data[i], &A->data[i + 1]);
			printf("Find it\n");
			flag = false;
			break;
		}
	}
	if (flag) {
		printf("Not find\n");
		int i = 0;
		for (i = 0; i < A->length && A->data[i] <= x; i++);
		if (i < A->length)
		{
			for (int j = A->length; j >= i; j--) {
				A->data[j + 1] = A->data[j];
			}
		}
		A->data[i] = x;
		A->length += 1;
	}
}

//答案方法 折半查找
void SearchExchangeInsert(List* A, int x) {
	int low = 0, mid = A->length / 2, high = A->length - 1;
	bool Isfind = false;
	while (low <= high) {
		mid = (low + high) / 2;
		if (x == A->data[mid]) {
			Isfind = true;
			printf("Find\n");
			break;
		}
		if (x > A->data[mid]) {
			low = mid + 1;
		}
		if (x < A->data[mid]) {
			high = mid - 1;
		}
	}
	if (Isfind && mid != A->length - 1) {
		printf("Swap\n");
		swap(&A->data[mid], &A->data[mid + 1]);
	}
	if (!Isfind) {
		int i = 0;
		printf("%d", low);
		for (i = A->length - 1; i > high; i--) {
			A->data[i + 1] = A->data[i];
		}
		A->data[i + 1] = x;
		A->length += 1;
	}
}

//P20.10
//〖2010统考真题〗设将n(n > 1)个整数存放到一维数组R中。设计一个在时间和空间两
//方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置, 即将R中的
//	数据由(X0,X1,…,Xn-1)变换为(Xp+Xp+1…,Xn-1,X0,X1…,Xp - 1)。要求
//	1)给出算法的基本设计思想
//	2)根据设计思想, 采用C或C++ + 或Java语言描述算法, 关键之处给出注释
//	3)说明你所设计算法的时间复杂度和空间复杂度

void MoveList(List* list, int MoveStep) {
	//BA=(A^-1*B^-1)^-1
	Reserve(list, 0, MoveStep - 1, MAX);
	Reserve(list, MoveStep, list->length - 1, MAX);
	Reserve(list, 0, list->length - 1, MAX);
}

//P20.11
//〖2011统考真题】一个长度为L(L≥1)的升序序列S, 处在第[L/2]个位置的数称为S的
//中位数。例如, 若序列S1 = (1, 13, 15, 17, 19), 则S1的中位数是15, 两个序列的中位数
//是含它们所有元素的升序序列的中位数。例如, 若S2 = (2, 4, 6, 8, 20), 则S1和S2的中位
//数是11。现在有两个等长升序序列A和B, 试设计一个在时间和空间两方面都尽可能
//高效的算法, 找出两个序列A和B的中位数。要求
//1)给出算法的基本设计思想
//2)根据设计思想, 采用C或C++或Java语言描述算法, 关键之处给出注释
//3)说明你所设计算法的时间复杂度和空间复杂度

//改编的归并排序
int FindMid(List A, List B) {
	int i = 0, j = 0;
	while (i + j != (A.length + B.length) / 2 - 1) {
		if (A.data[i] <= B.data[j]) {
			i++;
		}
		else {
			j++;
		}
	}
	return A.data[i] < B.data[j] ? A.data[i] : B.data[j];
}

//P20.12
//〖2013统考真题〗已知一个整数序列A = (a0, a1…, an-1), 其中0 ≤ ai < n(0 ≤i < n)。若
//	存在 ap1 = ap2 = ... = apm = x 且 m > n / 2   (0≤ Pk < n,1≤ 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。要求:
//1)给出算法的基本设计思想
//2)根据设计思想, 采用C或C十或Java语言描述算法, 关键之处给出注释
//3)说明你所设计算法的时间复杂度和空间复杂度

//次优算法，用空间换时间，类似桶排
int  FindMain(List A, int n) {
	int m_num = 0;
	int* Box = new int[n](); //动态申请一个大小为n的数组
	_for(i, 0, A.length) {
		Box[A.data[i]]++;
	}
	_for(i, 0, n) {
		if (Box[i] > n / 2) {
			return A.data[i];
		}
	}
	return -1;
}

//P21.13
//〖2018统考真题】给定一个含n(n≥1)个整数的数组, 请设计一个在时间上尽可能高效
//的算法, 找出数组中未出现的最小正整数。例如, 数组{ -5,3,2,3 }中未出现的最小正整数
//是1; 数组{ 1,2,3 }中未出现的最小正整数是4。要求
//1)给出算法的基本设计思想
//2)根据设计思想, 采用C或C艹语言描述算法, 关键之处给出注释
//3)说明你所设计算法的时间复杂度和空间复杂度

//用空间换时间
int FindMinNum(List A, int n) {
	int* Box = new int[n + 1]();
	_for(i, 0, A.length) {
		if (A.data[i] > 0 && A.data[i] <= n)
			Box[A.data[i]]++;
	}
	_for(i, 1, n) {
		if (!Box[i])
			return i;
	}
}

int main()
{
	List list1;
	List list2;
	list1.length = 4;
	list2.length = 5;
	int Data1[] = { 1,3,2,3 };
	int Data2[] = { 22,43,64,87,180 };

	for (int i = 0; i < list1.length; i++)
		list1.data[i] = Data1[i];

	for (int i = 0; i < list2.length; i++)
		list2.data[i] = Data2[i];

	printf("%d", FindMinNum(list1, 4));
}

源代码链接

如有不足，请多多指教~

Otto_1027
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
王道数据结构课后算法实现——2.2.4 2.2.5
Duanqi1的博客
07-08 138
题目：从有序顺序表中删除其值在给定值S与T之间的所有元素。
王道课后代码大题---树与二叉树
qq_46000102的博客
07-25 2951
一.二叉树的概念 1.求两结点的最近公共祖先结点（二叉树任意两个结点必然存在最近的公共祖先结点） 已知一颗二叉树按顺序存储结构进行存储，设计一个算法，求编号分别为i和j的两个结点的最近公共祖先结点 方法一 思想 最坏的情况是最近公共祖先结点为根节点，而且从最近的公共祖先结点到根节点的全部祖先结点都是公共的。由二叉树的顺序存储的性质可知，任意结点i的双亲结点的编号为i/2,求解i和j最近公共祖先结点的算法步骤如下(设从数组下标1开始存储） （1）若i>j,则结点i所在层次大于等于结点j所在层次。结
【Algorithm】选择问题与BFPRT算法
Esperanto.的博客
09-19 413
选择问题
BFPRT算法
weixin_30731287的博客
01-31 97
解决的问题：在一个数组中找到最小的k个数 常规解法：1、排序，输出前k个数，时间复杂度O（n*log(n)）。 2、利用一个大小为k的大根堆，遍历数组维持大根堆，最后返回大根堆就可以了，时间复杂度O(n*log(k))。 BFPRT解法： 利用快速排序的思路，选取一个划分值，小于这个数的放右边，等于这个数的放中间，大于这...
王道22数据结构课后习题（第二章2.2.3）
qq_50679120的博客
03-30 2727
1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错误信息并退出运行。 //删除顺序表L中的最小值元素结点，并通过引用类型参数e返回其值 bool Del_min(SqList &L, int &e) { if(L.length == 0) return false; int pos = 0 e = L.data[0]; for(i = 0 ; i < L.le
bfprt算法
赢在拼搏中
05-07 1884
转自bfprt算法中的部的那内容：           快速排序算法，将原始数据划分为两个部分，在分别对两部分数据按同样的方法分治递归，通过不断的递归将大的问题划分为2个小的字问题，达到快速的目的，算法的平均时间复杂度为O(n*logn), 这里的枢纽元的选择很关键，如果选择的是最大值或是最小值，那么划分的连个子问题将会严重不平衡，算法的最坏复杂度将会达到O(n*n)。关于枢纽元的选择，在算法导
数据结构-王道课后题-线性表（1）
Dr.sen的博客
06-30 1232
顺序表 1. 从顺序表中是删除最小元素，并返回该元素的值空出位置由最后一位填充。 bool Delete_min(sqList &L, ElemType &value){ if(L.length<=0){ //表为空，直接返回 return false ; } value=L.data[0]; int...
王道数据结构（课后编程题）--线性表部分
最新发布
m0_55703139的博客
07-07 56
该源码都是可以实现的，欢迎交流!
王道数据结构课后算法实现——2.2.6
Duanqi1的博客
07-09 208
从顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。
王道_线性表代码合集
LYY_Blog
10-03 843
线性表 线性表的基本操作 InitList(&L) //初始化表，构造一个空的线性表 Length(L) //求表长，返回线性表L长度 LocateElem(L,e) //按值查找操作，在表L中查找具有给定关键字个数 GetElem(L,i) //按位查找操作，在表L中查找第i个位置元素的值 ListInsert(&L,i,e) //插入操作，在表L中第i个位置插入指定元素 ListDelete(&L,i,&e) //删除操作，
408数据结构考研笔记——第二章线性表
qq_52189899的博客
03-17 352
408数据结构考研笔记整理，笔记+课后习题，习题是王道书的课后习题，整理主要用于个人学习归纳，侵删
"王道数据结构：线性表顺序表综合应用题1-高效删除元素算法
以上是王道数据结构-线性表中顺序表的一些综合应用题的题目描述。这些题目都要求设计算法，满足特定的时间复杂度和空间复杂度，并且要求对顺序表进行特定的操作。 在第一道题中，要求设计一个时间复杂度为 O(n)，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Otto_1027

蟹蟹你，我会继续努力的~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值