王道书第二章算法设计题

最新推荐文章于 2024-05-23 20:53:42 发布
最新推荐文章于 2024-05-23 20:53:42 发布
阅读量107 收藏 2
点赞数 1
文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75220252/article/details/130020484
版权

1.从顺序表中删除除具有最小元素的元素（假设唯一）并由函数返回被删除元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。

算法思想：搜素整个顺序表，查找最小元素并记住其位置，搜素结束后用最后一个元素填补空出的原最小值元素的位置

bool Del_Min(SeqList *L,int &val)
{
	if(0 == L->length)//用数组中的有效长度是否为0来判断数组是否为空
	{
		printf("数组为空!\n");
		return false;

	}
	val = L->data[0];//用val存放数组第一个元素，然后与后序数组元素进行比较
	int pos = 0;//用pos来记录最小元素的位置
	for(int i = 1; i<L->length; ++i)
	{
		if(L->data[i]<val)
		{
			val = L->data[i];
			pos = i;
			
		}
	}
	L->data[pos] = L->data[L->length-1];
	L->length--;//记得改变数组有效元素的个数
	return true;
}

 

 

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

算法思想：扫描顺序表L的前半部分元素，对于元素L->data[i](0<=i<L->length/2),将其与后半部分的对应元素L->data[L->length-1-i]进行交换

void Reverse(SeqList*L)
{
  int temp;//辅助变量
  for(int i = 0; i < L->length/2; ++i)//在计算机中L->length/2应是向下取整
  {
//通过中间变量改变数组元素的位置，因为仅借助一个变量temp，与问题规模无关，没有使用其他额外空间，所以空间复杂度O(1)
	  temp = L->data[i];
	  L->data[i] = L->data[L->length-1-i];
	  L->data[L->length-1-i] = temp;
  }
  return;
}

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

方法1—算法细想：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），扫描时将不等于x的元素移动到下标K的位置，并更新K值。扫描结束后修改L的长度

void Del_x_1(SeqList *L,int x)
{
  int i, k = 0;
  for(i = 0; i < L->length; ++i)
  {
	  if(x != L->data[i])
	  {
	     L->data[k] = L->data[i];//将数组中的不等于x的元素重新放在数组中
		 ++k;
	  }
	  
  }
  L->length = k;
  return;
}

规定数组的元素个数为10

 方法2—算法思想：用K记录顺序表中等于X的元素个数，表扫描L边统计K，并将不等于X的元素前移K个位置。扫描结束后需修改L的长度

void Del_x_2(SeqList *L,int x)
{
  int i = 0, k = 0;
  while(i < L->length)
  {
	  if(x == L->data[i])
	  {
	    ++k;
		
	  }
	  else
		  L->data[i-k] = L->data[i];
	  ++i;
  }
  L->length = L->length-k;//k是统计数组中等于x元素的个数
}

假设数组元素为1 2 9 2 3 4 5 6 7，x=2;删除数组所有为2的元素

i=0,k=0;   因为2!=1   所以L->data[0] = L->data[0]  数组元素为：1 2 9 2 3 4 5 6 7

i=1,k=0;   因为2==2  所以i = 2                                数组元素为：1 2 9 2 3 4 5 6 7      

i=2,k=1;   因为2!=9   所以L->data[1] = L->data[2]   数组元素为:  1 9 9 2 3 4 5 6 7

这是小编写的，复杂度为O(n^2),所以错误 

void del_x_1(SeqList *L,int x)
{
  int i = 0;
  while(i < L->length)
  {
	  if(L->data[i] == x)
	  {
		  for(int j = i; j < L->length; ++j)
		  {
			  L->data[j] = L->data[j+1];
			  L->length--;
		  }
	  }
	  else
		  ++i;
  }

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

小编的算法思想是：用k记录所有在s与t之间的元素个数，然后用后面的元素将其代替

bool Del_st(SeqList *L)
{
  int s,t;
  printf("请输入s和t的值：\n");
  scanf("%d%d",&s,&t);
  if(s >= t || L->length == 0)
	  return false;
  int i = 0,k = 0;
  while(i < L->length)
  {
	  if(L->data[i] > s && L->data[i] < t)
	  {
	    ++k;
	  }
	  else
		  L->data[i-k] = L->data[i];
	  ++i;
  }
  L->length = L->length-k;
  return true;
}

王道书上的 将给定值也删除了，小编认为这是有问题的

王道书上算法思想：先寻找值大于或等于s的第一个元素（第一个删除的元素），然后寻找值大于t的第一个元素（最后一个删除的元素的下一个元素），要将这段元素也删除，只需要将后面的元素前移

bool Del_s_t2(SeqList *L,int s, int t)
{
  int i,j;
  if(s >= t || L->length == 0)
	  return false;
  for(i = 0; i < L->length && L->data[i] < s; ++i);//找出值大于或等于s的第一个元素的位置
  if(i >= L->length)
	  return false;
  for(j = i; j < L->length && L->data[j] <= t;++j);//寻找值大于t的第一个元素的位置
  for(; j < L->length;++i,++j)
	  L->data[i] = L->data[j];//前移，这时会将s到t（若数组中元素包括s和）此时s和t元素也会被覆盖
  L->length = i;
  return true;

}

 第1~3题完整代码

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define InitSize 10

typedef struct Node
{
	int *data;
	int Maxsize,length;
}SeqList;
//函数说明
void InitList(SeqList *L);
bool Full(SeqList *L);
bool Append(SeqList *L,int x);
bool Del_Min(SeqList *L,int &val);
bool PrintList(SeqList *L);
bool Del_Min(SeqList *L,int &val);
void Reverse(SeqList*L);
//void del_x_1(SeqList *L,int x);
void Del_x_1(SeqList *L,int x);
void Del_x_2(SeqList *L,int x);
int main(void)
{
	SeqList L;
	InitList(&L);
	Append(&L,4);
	Append(&L,2);
	Append(&L,8);
	Append(&L,1);
	Append(&L,6);
	Append(&L,3);
	Append(&L,18);
	Append(&L,11);
	Append(&L,-1);
	Append(&L,0);
	int val;
	PrintList(&L);
	/*Del_Min(&L,val);
	printf("删除元素是：%d\n",val);
	printf("数组剩余元素为：\n");
	PrintList(&L);*/
	/*Reverse(&L);
	printf("逆序之后的元素为：\n");
	PrintList(&L);*/
	//del_x_1(&L,-1);
	//Del_x_1(&L,11);
	Del_x_2(&L,11);
	printf("删除所有值为11的元素之后剩下元素为：\n");
	
	PrintList(&L);
	return 0;
}
//初始化 
void InitList(SeqList *L)
{
	L->data = (int *)malloc(sizeof(int)*InitSize);
	if(NULL == L->data)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	L->Maxsize = InitSize;
	L->length = 0;
	return;
}

//判断数组是否满 
bool Full(SeqList *L)
{
	if(L->Maxsize == L->length)
	return true;
	else
	return false;
}

//增加数组元素
bool Append(SeqList *L,int x)
{
	if(Full(L))
	return false;
	L->data[L->length] = x;
	L->length++;
	return true;
}
//遍历输出
bool PrintList(SeqList *L)
{
	if(0 == L->length)
	return false;
	for(int i = 0; i < L->length; ++i)
	{
	    printf("%d\n",L->data[i]);
	}
	return true;
}

//王道书--第二章--应用题--第一题
//算法思想：搜素整个顺序表，查找最小元素并记住其位置，搜素结束后用最后一个元素填补空出的原最小值元素的位置
bool Del_Min(SeqList *L,int &val)
{
	if(0 == L->length)
	{
		printf("数组为空!\n");
		return false;

	}
	val = L->data[0];
	int pos = 0;
	for(int i = 1; i<L->length; ++i)
	{
		if(L->data[i]<val)
		{
			val = L->data[i];
			pos = i;
			
		}
	}
	L->data[pos] = L->data[L->length-1];
	L->length--;
	return true;
}

//王道书--第二章--应用题--第二题
//算法思想：扫描顺序表L的前半部分元素，对于元素L->data[i](0<=i<L->length/2),将其与后半部分的对应元素L->data[L->length-1-i]进行交换
void Reverse(SeqList*L)
{
  int temp;//辅助变量
  for(int i = 0; i < L->length/2; ++i)//在计算机中L->length/2应是向下取整
  {
	  temp = L->data[i];
	  L->data[i] = L->data[L->length-1-i];
	  L->data[L->length-1-i] = temp;
  }
  return;
}
//王道书--第二章--应用题--第三题
//自己的算法时间复杂度应该为O(n^2),不符合题意
/*void del_x_1(SeqList *L,int x)
{
  int i = 0;
  while(i < L->length)
  {
	  if(L->data[i] == x)
	  {
		  for(int j = i; j < L->length; ++j)
		  {
			  L->data[j] = L->data[j+1];
			  L->length--;
		  }
	  }
	  else
		  ++i;
  }
}*/

//解法1：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），扫描时将不等于x的元素移动到下标K的位置，并更新K值。扫描结束后修改L的长度
void Del_x_1(SeqList *L,int x)
{
  int i, k = 0;
  for(i = 0; i < L->length; ++i)
  {
	  if(x != L->data[i])
	  {
	     L->data[k] = L->data[i];
		 ++k;
	  }
	  
  }
  L->length = k;
  return;
}

//解法2：用K记录顺序表中等于X的元素个数，表扫描L边统计K，并将不等于X的元素前移K个位置。扫描结束后需修改L的长度
void Del_x_2(SeqList *L,int x)
{
  int i = 0, k = 0;
  while(i < L->length)
  {
	  if(x == L->data[i])
	  {
	    ++k;
		
	  }
	  else
		  L->data[i-k] = L->data[i];
	  ++i;
  }
  L->length = L->length-k;
}

第4题完整代码

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define InitSize 10

typedef struct Node
{
	int *data;
	int Maxsize,length;
}SeqList;

//函数说明
void InitList(SeqList *L);
bool Full(SeqList *L);
bool Append(SeqList *L,int x);
bool PrintList(SeqList *L);
bool Del_st(SeqList *L);
bool Del_s_t2(SeqList *L,int s, int t);
int main(void)
{
    SeqList L;
  	InitList(&L);
	Append(&L,1);
	Append(&L,2);
	Append(&L,3);
	Append(&L,4);
	Append(&L,5);
	Append(&L,6);
	Append(&L,7);
	Append(&L,8);
	Append(&L,9);
	Append(&L,10);
	printf("增加元素之后数组的值为：\n");
	PrintList(&L);
	//Del_st(&L);
	//PrintList(&L);
	Del_s_t2(&L,2,6);
	printf("删除元素之后数组元素为：\n");
	PrintList(&L);
    return 0;
}
  
//初始化 
void InitList(SeqList *L)
{
	L->data = (int *)malloc(sizeof(int)*InitSize);
	if(NULL == L->data)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	L->Maxsize = InitSize;
	L->length = 0;
	return;
}

//判断数组是否满 
bool Full(SeqList *L)
{
	if(L->Maxsize == L->length)
	return true;
	else
	return false;
}

//增加数组元素
bool Append(SeqList *L,int x)
{
	if(Full(L))
	return false;
	L->data[L->length] = x;
	L->length++;
	return true;
}
//遍历输出
bool PrintList(SeqList *L)
{
	if(0 == L->length)
	return false;
	for(int i = 0; i < L->length; ++i)
	{
	    printf("%d\n",L->data[i]);
	}
	return true;
}

bool Del_st(SeqList *L)
{
  int s,t;
  printf("请输入s和t的值：\n");
  scanf("%d%d",&s,&t);
  if(s >= t || L->length == 0)
	  return false;
  int i = 0,k = 0;
  while(i < L->length)
  {
	  if(L->data[i] > s && L->data[i] < t)
	  {
	    ++k;
	  }
	  else
		  L->data[i-k] = L->data[i];
	  ++i;
  }
  L->length = L->length-k;
  return true;
}

bool Del_s_t2(SeqList *L,int s, int t)
{
  int i,j;
  if(s >= t || L->length == 0)
	  return false;
  for(i = 0; i < L->length && L->data[i] < s; ++i);
  if(i >= L->length)
	  return false;
  for(j = i; j < L->length && L->data[j] <= t;++j);
  for(; j < L->length;++i,++j)
	  L->data[i] = L->data[j];
  L->length = i;
  return true;

}

尘桥湖
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024王道数据结构第二章链表第2题
LHY的博客
10-22 49
在带头结点的单链表中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法以实现上述操作。
王道线性表算法设计题代码
08-05
王道线性表算法设计题代码
王道数据结构链表算法题第二题
weixin_43788095的博客
08-23 92
在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一。
王道数据结构第二章线性表应用题一
qq_42673689的博客
08-29 127
王道数据结构第二章线性表综合应用题01
王道课后习题2.3.20：非循环双向链表访问频度域
qq_34941153的博客
08-25 1418
题目描述： 设有一头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred(前驱指针)、data(数据)和next(后继指针)域外，还有一个访问频度域freq。在链表被起用前，其值均初始化为零。每当在链表中进行一次Locate(L，x)运算时，令元素值为x的结点中freq域的值增1，并使此链表中结点保持按访问频度非增(递减)的顺序排列，同时最近访问的结点排在频度相同的结点的最后，以便使...
王道书串和 KMP 算法内容优化
08-08
王道书串和 KMP 算法内容优化，对考研kmp算法的详细讲解和习题。
王道计组第二章错题.pdf
11-12
王道计组第二章错题.pdf
王道算法题
02-13
非原创的为什么能要15c币，csdn别这样玩了 ...................................................................................................................................................................
王道第二章 -线性表的操作
07-16
第二节 线性表的顺序表示 一、顺序表的定义 线性表的顺序存储又称顺序表，是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻，即：数据逻辑顺序以及物理顺序...
王道数据结构第二章2.20题
Yannie's Blog
04-18 361
这道题之前有难到我的一个点是，如何去将最近访问的节点排在频度相同的节点前面。 这道题解决方法就是：当你每找到一个想要找的值，就将其从链表上摘除掉，然后，在链表中寻找它应该插入的位置。这里的话，也就是比较频度值，当我们的频度值相同的时候，我们只要也采取将节点插入到它们前面的策略，就可以实现将最近访问的节点排在频度相同的节点前面。 代码如下： #include<stdio.h> #inc...
2021-08-13 王道 数据结构 p38 第20题
qq_44801423的博客
08-13 65
第2章 线性表的链式表示 综合应用题 第20题 #include <stdio.h> #include <stdlib.h> //malloc所在头文件 #include <iostream> using namespace std; typedef int ElemType; typedef struct dnode { ElemType data; //双链表中的数据域 int len,f
克鲁斯卡尔（Kruskal）算法生成最小生成树(MST)原理及算法实现
2301_77118121的博客
05-20 582
克鲁斯卡尔（Kruskal）算法生成最小生成树(MST)原理及算法实现
算法训练营day34
stmfresher的博客
05-22 176
贪心算法的思路是，如果当前的和为负数的，就舍去这个和然后重新进行sum累加，同时用reslut记录局部最优，就是每次累加判断sum > max 如果大于就更新max。把大的饼干分给胃口最大的。暴力解法会超时，代码如下。
每周一算法：Prim算法求最小生成树
少儿编程乔老师
05-23 999
在一个无向图中求边权和最小的生成树，即无向连通图的最小生成树（Minimum Spanning Tree，MST）。本文介绍使用Prim算法求最小生成树。
leetcode 打卡#day29 39. 组合总和、40. 组合总和 II、131. 分割回文串
weixin_41835324的博客
05-21 216
【代码】leetcode 打卡#day29 39. 组合总和、40. 组合总和 II、131. 分割回文串。
leetCode-hot100-数组专题之区间问题
m0_49074706的博客
05-23 968
leetCode-hot100-数组专题之区间问题
48、spfa求最短路
weixin_44010641的博客
05-21 294
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。如果路径不存在，则输出”impossible”。输出一个整数，表示1号点到n号点的最短距离。图中涉及边长绝对值均不超过10000。数据保证不存在负权回路。第一行包含整数n和m。
线段（线性dp）
最新发布
weixin_73550568的博客
05-23 355
从上一行右端点转移同理。边界f[1][0]=r[1]+r[1]-l[1]-1,f[1][1]=r[1]-1，然后直接搞就行了，时间复杂度O(n)。那么转移就很简单了，走完当前行且停到左端点，那么一定是从右端点过来的，那么从上一行左端点转移的话就是。f[i][0]=abs(上一行左端点的坐标-本行右端点的坐标+本行线段长度)f[i][0]表示走完第i行且停在第i行的左端点最少用的步数。f[i][1]同理，停在右端点的最少步数。
王道计组学习第二章章
09-10
在计算机组成原理的第二章中，通常会涉及到以下主题： 1. 指令系统：介绍计算机指令的基本概念和表示方法，包括指令的操作码、操作数和寻址方式等。 2. 数据表示和处理：介绍计算机中数据的表示方式，包括整数、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值