【数据结构王道2023课后练习题】线性表

已于 2022-07-31 15:57:40 修改
阅读量625 收藏 7
点赞数
分类专栏： # 数据结构 C语言永垂不朽 文章标签： 数据结构 算法 c语言
于 2022-07-14 00:12:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VIAww/article/details/125773981
版权

线性表

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

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

#include<stdio.h> 
#define MaxSize 10

typedef struct{
	int data[MaxSize];
	int length;
}SqList; 


void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

bool InputList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

bool Del_Min(SqList &L,int &value){
	// 删除顺序表中最小值元素结点，并通过引用型参数value返回值
	// 若删除成功，则返回true，否则返回false
	if(L.length==0) 
		return false;	// 表空，终止操作返回
	value=L.data[0] ;
	int pos=0;	// 假定0号元素值最小
	for(int i=1;i<L.length;i++) 
		if(L.data[i]<value){
			value=L.data[i];
			pos=i;
		}
	L.data[pos]=L.data[L.length-1];	// 空出的位置由最后一个元素填补
	L.length--;
	return true; 
} 

int main(){
	int value; 
	SqList L;
	InitList(L);
	printf("请输入你的顺序表：\n") ;
	InputList(L);
	printf("你的顺序表为：\n") ;
	PrintList(L);
	Del_Min(L,value);
	printf("删除最小值并填补后的顺序表为：\n") ;
	PrintList(L);
	printf("删除的元素为%d\n",value) ;
}
	return 0;

在这里插入图片描述
2. 设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。

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

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

#include<stdio.h> 
#define MaxSize 10

typedef struct{
   int data[MaxSize];
   int length;
}SqList; 


void InitList(SqList &L){
   for(int i=0;i<MaxSize;i++)
   	L.data[i]=0;
   L.length=0;
}

bool InputList(SqList &L){
   for(int i=0;i<MaxSize;i++){
   	scanf("%d",&L.data[i]);
   	L.length++;
   }
}

bool PrintList(SqList &L){
   if(L.length==0)
   	return false;
   for(int i=0;i<length;i++){
   	printf("%d ",L.data[i]);
   }
   printf("\n");
   return true;
}

void Reverse(SqList &L) {
   int temp;	// 辅助变量
   for(int i=0;i<L.length/2;i++) {
   	temp=L.data[i];	// 交换L.data[i]与L.data[L.length-i-1]
   	L.data[i]=L.data[L.length-i-1];
   	L.data[L.length-i-1]=temp;
   }
}

int main(){
   SqList L;
   InitList(L);
   printf("请输入你的顺序表：\n") ;
   InputList(L);
   printf("你的顺序表为：\n") ;
   PrintList(L);
   Reverse(L);
   printf("逆置后后的顺序表为：\n") ;
   PrintList(L);
   return 0;
}

在这里插入图片描述
3. 对长度为n的顺序表L，编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素。

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

#include<stdio.h> 
#define MaxSize 10

typedef struct{
	int data[MaxSize];
	int length;
}SqList; 


void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

bool InputList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

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

void del_x_1(SqList &L, int x) {
	// 本算法实现删除顺序表L中的所有值为x的数据元素
	int k=0,i;	// 记录值不为x的元素个数
	for(i=0;i<L.length;i++) {
		if(L.data[i]!=x){
			L.data[k]=L.data[i];
			k++;	// 不等于x的元素增1 
		}
	}
	L.length=k;	// 顺序表L的长度等于k 
}

// 解法2：用k记录顺序表中不等于x的元素（即需要保存的元素个数），边扫描L边统计k，并将不等于x的元素前移k个位置。扫描结束后修改L的长度。
void del_x_2(SqList &L, int x) {
	int k=0,i=0;	// 记录值为x的元素个数
	while(i<L.length){
		if(L.data[i]==x)
			k++;
		else
			L.data[i-k]=L.data[i];	// 当前元素前移k个位置
		i++; 
	}
	L.length=L.length-k;	// 顺序表L的长度递减 
}

int main(){
	int x;
	SqList L;
	InitList(L);
	printf("请输入你的顺序表：\n") ;
	InputList(L);
	printf("你的顺序表为：\n") ;
	PrintList(L);
	printf("请输入你要删除的元素x：");
	scanf("%d",&x) ;
//	del_x_1(L,x);
	del_x_2(L,x);
	printf("删除x后的顺序表为：\n") ;
	PrintList(L);
	return 0;
}

在这里插入图片描述

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

// 注意：区别于3。因为是有序表，所以删除的元素必然是相连的整体。 
// 思想： 先寻找值大于等于s的第一个元素（第一个删除的元素） ，然后寻找值大于t的第一个元素（最后一个删除的元素的下一个元素），要将这段元素删除，只需直接将后面的元素前移。 
#include<stdio.h> 
#define MaxSize 10

typedef struct{
	int data[MaxSize];
	int length;
}SqList; 


void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

bool InputList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

bool Del_s2t(SqList &L,int s,int t){
	// 删除有序顺序表L中值在给定值s与t之间的所有元素
	int i=0,j=0;
	if(s>t||L.length==0) 
		return false;
	for(;i<L.length&&L.data[i]<s;i++);	// 寻找值大于等于s的第一个元素
	if(i>L.length)
		return false;	// 所有元素值均小于s，返回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];
	L.length=i;
	return true;
}


int main(){
	int s,t;
	SqList L;
	InitList(L);
	printf("请输入你的有序顺序表：\n") ;
	InputList(L);
	printf("你的有序顺序表为：\n") ;
	PrintList(L);
	printf("请输入s和t：");
	scanf("%d,%d",&s,&t) ;
	Del_s2t(L,s,t);
	printf("删除%d到%d的值后的有序顺序表为：\n",s,t) ;
	PrintList(L);
	return 0;
}

在这里插入图片描述

  1. 从顺序表中删除其值在给定s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或者顺序表为空，则显示出错信息并退出。
// 5. 从顺序表中删除其值在给定s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或者顺序表为空，则显示出错信息并退出。

// 思想：从前向后扫描顺序表L，用k记录下元素值在s到t之间元素的个数（初始时k=0）。对于当前扫描的元素，若其值不在s到t之间，则前移k个位置；否则执行k++。
// 由于这样每个不在s到t之间的元素仅移动一次，因此算法效率高。
#include<stdio.h> 
#define MaxSize 10

 typedef struct{
	int data[MaxSize];
	int length;
}SqList; 


void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

bool InputList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

bool Del_s2t(SqList &L,int s,int t){
	// 删除顺序表L中值在给定值s与t之间的所有元素
	int i=0,k=0;
	if(s>t||L.length==0) 
		return false;
	for(i=0;i<L.length;i++){
		if(L.data[i]>=s&&L.data[i]<=t)
			k++;
		else
			L.data[i-k]=L.data[i];	// 当前元素前移k个位置 
	}
	L.length-=k;
	return true;
}


int main(){
	int s,t;
	SqList L;
	InitList(L);
	printf("请输入你的顺序表：\n") ;
	InputList(L);
	printf("你的顺序表为：\n") ;
	PrintList(L);
	printf("请输入s和t：");
	scanf("%d,%d",&s,&t) ;
	Del_s2t(L,s,t);
	printf("删除%d到%d的值后的顺序表为：\n",s,t) ;
	PrintList(L);
	return 0;
}

在这里插入图片描述

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

// 思想：有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同，则继续往后判断，若不同，则插入前面的非重复有序表最后，直至判断到表尾为止。

#include<stdio.h> 
#define MaxSize 10

typedef struct{
	int data[MaxSize];
	int length;
}SqList; 


void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

bool InputList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		scanf("%d",&L.data[i]);
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

bool Delete_Same(SqList &L){
	if(L.length==0)
		return false;
	int i,j;	// i存储第一个不相同的元素，j为工作指针 
	for(i=0,j=1;j<L.length;j++){
		if(L.data[i]!=L.data[j])	// 查找下一个与上个元素值不同的元素 
			L.data[++i]=L.data[j] ;	// 找到后，将元素前移 
	}
	L.length=i+1;
	return true;
}
int main(){
	SqList L;
	InitList(L);
	printf("请输入你的有序顺序表：\n") ;
	InputList(L);
	printf("你的有序顺序表为：\n") ;
	PrintList(L);
	Delete_Same(L);
	printf("删除重复值后的有序顺序表为：\n",s,t) ;
	PrintList(L);
	return 0;
}

在这里插入图片描述
7. 将两个有序顺序表合成一个新的有序顺序表， 并由函数返回结果顺序表。

// 7. 将两个有序顺序表合成一个新的有序顺序表， 并由函数返回结果顺序表。

// 思想：首先，按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表的后面。

#define MaxSize 10
#include<stdio.h>
typedef struct {
	int data[MaxSize];
	int length;
}SqList;

void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

void InputList(SqList &L){
	int i=0;
	while(scanf("%d",&L.data[i++])!=EOF){
		L.length++;
	} 
}
bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

bool Merge(SqList A,SqList B,SqList &C){
	// 将有序顺序表A与B合并为一个新的有序顺序表C
	if(A.length+B.length>MaxSize) 	// 大于顺序表的最大长度 
		return false;	
	int i=0,j=0,k=0;
	while(i<A.length&&j<B.length){ //循环，两两比较，小者存入结果表 
		if(A.data[i]<=B.data[j])
			C.data[k++]=A.data[i++];
		else
			C.data[k++]=B.data[j++];
	} 	 
	while(i<A.length)	// 还剩一个没有比较完的顺序表
		C.data[k++] = A.data[i++];
	while(j<B.length)	
		C.data[k++]=B.data[j++];
	C.length=k;
	return true;
}


int main(){
	SqList A,B,C;
	InitList(A);
	InitList(B);
	InitList(C);
	printf("请输入第一个有序顺序表:\n");
	InputList(A);
	printf("请输入第二个有序顺序表:\n");
	InputList(B);
	printf("你的第一个有序顺序表为：\n") ;
	PrintList(A);
	printf("你的第二个有序顺序表为：\n") ;
	PrintList(B);
	Merge(A,B,C) ;
	printf("处理好后的新顺序表为:\n") ;
	PrintList(C);
	return 0;
}

在这里插入图片描述

  1. 已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3…am)和(b1,b2,b3,…,bn)。
    编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,…,bn)放在(a1,a2,a3…am)的前面。
/* 8.已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3...am)和(b1,b2,b3,...,bn)。
编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,...,bn)放在(a1,a2,a3...am)的前面。*/ 
/*思想：先将数组A[m+n]中的全部元素(a1,a2,a3,...,am,b1,b2,b3,...bn) 原地逆置为(bn,bn-1,bn-2,...,b1,am,am-1,am-2,...,a1)，
再对前n个元素和后m个元素分别使用逆置算法，即可得到(b1,b2,b3,...,bn,a1,a2,a3...am)，从而实现顺序表的位置互换。*/ 

#include<stdio.h> 
#define MaxSize 10
typedef int DataType;
typedef struct{
	DataType data[MaxSize];
	DataType length;
}SqList; 

void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

void InputList(SqList &L){
	int i=0;
	while(scanf("%d",&L.data[i++])!=EOF){
		L.length++;
	} 
}

bool PrintList(SqList &L){
	if(L.length==0)
		return false;
	for(int i=0;i<L.length;i++){
		printf("%d ",L.data[i]);
	}
	printf("\n");
	return true;
}

void Sql2Mat(SqList LA,SqList LB, DataType A[]){
	int i,j,k=0;
	for(i=0;i<LA.length;i++)
		A[k++]=LA.data[i];
	for(j=0;j<LB.length;j++)
		A[k++]=LB.data[j];
}


void Reverse(DataType A[],int left,int right,int arraySize){
	// 逆转(aleft,aleft+1,aleft+2...,aright)为(aright,aright-1,...,aleft)
	if(left>=right||right>=arraySize) 
		return;
	int mid=(left+right)/2;
	for(int i=0;i<=mid-left;i++){
		DataType temp=A[left+i];
		A[left+i]=A[right-i];
		A[right-i]=temp; 
	}
}

void Exchange(DataType A[],int m,int n,int arraySize){
	/*
	数组A[m+n]中，从0到m-1存放顺序表(a1,a2,a3...am)，从m到m+1存放(b1,b2,b3,...,bn)，
	算法将这两个表的位置互换。  
	*/
	Reverse(A,0,m+n-1,arraySize);
	Reverse(A,0,n-1,arraySize);
	Reverse(A,n,m+n-1,arraySize);
}

int main(){ 
	DataType A[MaxSize] ;
	SqList LA,LB;
	InitList(LA);
	InitList(LB);
	printf("请输入顺序表A:\n");
	InputList(LA);
	printf("顺序表A为:\n");
	PrintList(LA);
	printf("请输入顺序表B:\n");
	InputList(LB);
	printf("顺序表B为:\n");
	PrintList(LB);
	printf("将顺序表存入数组A\n");
	Sql2Mat(LA,LB,A);
	printf("数组A为:\n");
	for(int i=0;i<MaxSize;i++){
		printf("%d ",A[i]);
	}
	printf("\n");
	Exchange(A,5,5,MaxSize);
	printf("交换后的数组为:\n");
	for(int i=0;i<MaxSize;i++){
		printf("%d ",A[i]);
	}
	return 0;
}

在这里插入图片描述

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

#include<stdio.h> 
#define MaxSize 10 

typedef struct{
	int data[MaxSize];
	int length; 
}SqList;

void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;
	L.length=0;
}

void InputList(SqList &L){
	int i=0;
	while(scanf("%d",&L.data[i++])!=EOF){
		L.length++;
	}
}

bool PrintList(SqList &L){
	if(L.length==0)	
		return false;
	for(int i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
	return true;
}

void SqL2Mat(SqList L,int A[]){
	for(int i=0;i<L.length;i++)
		A[i]=L.data[i];
}

void SearchExchangeInsert(int A[],int x) {
	int low=0,high=MaxSize-1,mid;
	while(low<high){
	mid=(low+high)/2;	// 找中间位置 
	if(A[mid]==x)break;	// 找到x，退出while循环 
	else if(A[mid]<x)low=mid+1;		// 到中点mid的右边去查找
	else high=mid-1;	// 到中点左边去查找
}
	// 下面的if只会执行一个 
	if(A[mid]==x&&mid!=MaxSize-1) {
		// 若最后一个元素与x相等，则不存在与其后继交换的操作
		int t=A[mid] ;
		A[mid]=A[mid+1];
		A[mid+1]=t;
	}
	if(low>high) {// 查找失败，插入数据元素x 
		int i=0;
		for(i=MaxSize-1;i>high;i--) A[i+1]=A[i]; // 后移元素
		A[i+1]=x;	// 结束插入 
	}
}

int main() {
	SqList L;
	int A[MaxSize] ;
	int x;
	InitList(L);
	printf("请输入线性表:\n") ;
	InputList(L);
	printf("你输入的线性表为:\n");
	PrintList(L) ;
	printf("将线性表转为数组:\n") ;
	SqL2Mat(L,A);
	printf("请输入要查询的数据元素x:\n");
	scanf("%d",&x);
	SearchExchangeInsert(A,x);
	printf("操作完后的数组为:\n");
	for(int i=0;i<MaxSize;i++)
		printf("%d ",A[i]);
	return 0;
}

在这里插入图片描述

橡皮鸭小队长
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【2023王道数据结构】【栈、队列和数组—page70—04】C、C++完整实现（可直接运行）
CSDN 精品推荐
04-27 262
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ 题目： 解题思路： >将链表前半元素压进栈中 >然后依次出栈、遍历链表后半部分元素进行比较 代码实现： #include <iostream> using namespace std; // 单链表定义 typedef struct LNode { char data; struct LNode *next; }.
经典的数据结构习题大全，有答案，全面，覆盖到各个知识点，有1800个题
04-17
真是不可多得的好资源，有很多经典习题，包括历年考研的数据结构习题，是学习数据结构最好的助手
【2023王道数据结构】【线性表】【P18】【02】C、C++完整实现（可直接运行）
CSDN 精品推荐
04-25 1112
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ 题目： 解题思路： >由于题目要求算法的空间复杂度为O(1)，所以肯定是不能开辟新的数据进行复制的 >所以这里定义个临时变量，用于保存当前值 >不断交换首尾对应位置的元素 >由于首尾对称，所以只需要循环表长的一半 代码实现： #include <iostream> using namespace std; #defin.
【2023王道数据结构】【栈、队列和数组】思维拓展C、C++完整实现（可直接运行）
CSDN 精品推荐
05-01 566
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ ✌ 题目及题解持续更新中 【2023王道数据结构目录】课后算法设计题C、C++代码实现完整版大全 题目： 设计一个栈，使它可以在O(1)的时间复杂度内实现Push、Pop和min操作。所谓min操作，是指得到栈中最小的元素。 解题思路： >设置两个栈，分别是主栈和辅助栈 >主栈存储所有元素 >辅助栈保存当前栈的最小值，栈顶保存最小值 .
【王道2023考研计算机数据结构复习指导课后代码题】——05.找到两个单链表的第一个公共结点
IronmanJay的博客
06-07 273
给定两个单链表，编写算法找出两个链表的公共结点。
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
王道考研数据结构第二讲-线性表
07-21
和我的王道考研数据结构专题中的代码对应，可以参看https://blog.csdn.net/zhangbaodan1/article/details/81142428
《数据结构》第二章线性表习题.doc
12-01
《数据结构》第二章线性表习题.doc
数据结构-顺序结构的线性表
最新发布
01-06
数据结构-顺序表
【2023王道数据结构】【串—page119—02】C、C++完整实现（可直接运行）
CSDN 精品推荐
05-03 736
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ ✌ 题目及题解持续更新中 【2023王道数据结构目录】课后算法设计题C、C++代码实现完整版大全 题目： 设有字符串S=‘aabaabaabaac’，P=‘aabaac’。 1）求出P的next数组。 2）若S作主串，P作模式串，试给出KMP算法的匹配过程。 解题思路： 代码实现： #include <iostream> using namespace std; #define MAXSIZE 100 //定义串的结构 t.
王道数据结构_第二章线性表_综合应用题
@ZhengLan的博客
04-25 478
/** *综合应用题 */ #include<iostream> #define maxsize 100 #define ElemType int using namespace std; typedef struct{ ElemType data[maxsize]; int length; }list; //初始化创建顺序表 void initList(list &l){ for(int i = 0; i < 5; i++){ l.data[i] = i+1;
已知在一维数组A[m+n]中依次存放两个线性表（a1,a2,a3,...,am）和（b1,b2,b3,...,bn）。试编写一个函数，将数组中两个顺序表的位置互换，即将线性表b放在线性表a前
qq_43687652的博客
03-25 1497
算法思想： 先将数组A[m+n]中的全部元素（a1,a2,a3,…,am,b1,b2,b3,…,bn）原地逆置为（bn,…,b3,b2,b1,am,…,a3,a2,a1），再对前n个元素和后m个元素分别使用逆置算法，即可得到（b1,b2,b3,…,bn,a1,a2,a3…,am），从而实现顺序表的位置互换。 本题代码如下： .........
已知一维数组A[M+N]中依次存放两个线性表（a1,a2,a3,a4....an与b1,b2,b3...bn）试写函数将两顺序表的位置互换
weixin_42803102的博客
05-13 7191
已知一维数组A[M+N]中依次存放两个线性表（a1,a2,a3,a4....an与b1,b2,b3...bn）试写函数将两顺序表的位置互换，即将b1,b2,b3...bn放在a1,a2,a3,a4....an前面 刚看这个题，想的第一种算法是 先将M，N进行比较，如果M大，则将b顺序表前移到表头 即 a1 a2 a3…an b1 b2 b3…bn 变成 b1 b2 b3…bn a(n+1) a...
王道数据结构——线性表中顺序表的一些综合应用题
aisebu7819的博客
09-20 435
1.长度为n的顺序表中，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，用于删除线性表中所有值为x的数据元素。（满足要求的数放在第k位上） 1 #include <cstdio> 2 3 /*输出数组名为a、长度为n的数组*/ 4 void print(int *a, int n){ 5 for(int i = 0;i < n...
ch2 8.已知在一维数组A[m+n]中依次存放两个线性表（a1-am）,（b1-bm）。将数组中两个顺序表位置互换
葵莳雨
08-09 2063
#include<iostream> using namespace std; #define MaxSize 100 //已知在一维数组A[m+n]中依次存放两个线性表（a1-am）,（b1-bm）。将数组中两个顺序表位置互换 //三次逆置，整体逆置，两次内部逆置 void reverse(int A[],int left,int right,int arraySize){ if(left>=right || right>=arraySize) return; .
2.2.8 已知在一维数组A[m + n]中依次存放两个线性表（a1, a2, a3, a4....am）与（b1, b2, b3...bn）。试写函数将两顺序表的位置互换
weixin_45837835的博客
03-30 1723
已知在一维数组A[m + n]中依次存放两个线性表（a1, a2, a3, a4…am）与（b1, b2, b3…bn）。试写函数将两顺序表的位置互换，即将（b1, b2, b3…bn）放在（a1, a2, a3, a4…am）前面 思路1：既然是数组，我想的是把数组元素对换，比如：A[0]（a1）与A[m]（b1）对换，但这样就要考虑一对一对调之后就会有元素剩下的情况 思路2：把bn元素一个个插到a1前面，这样太麻烦了 思路3（参考算法思想）： void Reverse(DataType A[],in
【2023王道数据结构】【线性表】【P18】【04】C、C++完整实现（可直接运行）
CSDN 精品推荐
04-25 634
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ 题目： 解题思路： >该题是有序顺序表，所以只需要找到找到大于t的值 >将其大于t的值前移到第一个大于等于s的位置 >所以该题的关键就是找到第一个大于t和第一个大于等于s的位置 代码实现： #include <iostream> using namespace std; #define Maxsize 50 // 定义顺序.
《2023王道数据结构》书中P18，综合应用题11解法。
weixin_52800300的博客
07-01 306
《王道数据结构》书中P18，综合应用题11解法。
数据结构线性表练习题
09-10
数据结构线性表练习题涵盖了多个题型，包括线性表的存储结构、链表的判空、单链表的建立、顺序表和单链表的插入删除操作、双链表的插入删除操作以及循环链表。其中，一道题目是关于对具有n个元素的线性表建立单链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值