27.顺序表练习题目（1）（2023王道数据结构2.2.3前8题）

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量107 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54708219/article/details/132892707
版权

【这里所有解答都写的是全部代码，目的是让大家能够直接复制上手运行，感受代码的运行过程，而不单单只是写了一个函数】

试题1：（王道2023数据结构综合应用题1）

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

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

bool Del_Min(SqList &L){
//删除顺序表中的最小值元素结点
 	if(L.length==0)
 		return false;  //表空，中止操作返回
    ElemType 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];  //让value始终记忆当前具有最小值的元素 
		 	pos = i;
		}
	L.data[pos] = L.data[L.length-1];  //空出的位置由最后一个元素填补 
	L.length--;
	return true;  //此时value即为最小值 
} 

int main(){
	int n,e;
	cout<<"请输入顺序表长度"<<endl;
	cin>>n;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n);	 //顺序表传值 
	Print(L);  //打印顺序表
	Del_Min(L);  //删除顺序表中的最小值
	Print(L);  //再次打印输出
	return 0;
}

输出：

请输入顺序表长度
5
顺序表初始化完成
请传入数值
3 7 5 2 4
目前顺序表为：
3       7       5       2       4
目前顺序表为：
3       7       5       4

试题2：（王道2023数据结构综合应用题2）

设计一个高效算法，将顺序表中的所有元素逆置，要求算法的空间复杂度是O（1）；

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

void Reverse(SqList &L){
//将顺序表所有元素逆置
    ElemType value;
	for(int i = 0; i < L.length/2; i++){
		value = L.data[i];
		L.data[i] = L.data[L.length - 1 - i];
		L.data[L.length - 1 - i] = value;
	}
} 

int main(){
	int n,e;
	cout<<"请输入顺序表长度"<<endl;
	cin>>n;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n);	 //顺序表传值 
	Print(L);  //打印顺序表
	Reverse(L);  //将顺序表逆置
	Print(L);  //再次打印输出
	return 0;
}

输出：

请输入顺序表长度
5
顺序表初始化完成
请传入数值
5 4 32 1 8
目前顺序表为：
5       4       32      1       8
目前顺序表为：
8       1       32      4       5

试题3：（王道2023数据结构综合应用题3）

对长度为n的顺序表L，设计一个时间复杂度为O（n），空间复杂度为O（1）的算法，删除线性表中所有值为x的元素。

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

void del_x(SqList &L,int x){
//删除所有值为x的元素
	int j = 0;  //j记录x元素的个数
	for(int i = 0; i < L.length; i++){
		if (L.data[i] == x)
			j = j + 1;
		L.data[i+1 - j] = L.data[i+1];  //前移元素
	}
	L.length = L.length - j;  //更新线性表长度
} 

int main(){
	int n,e,x;
	cout<<"请输入顺序表长度"<<endl;
	cin>>n;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n);	 //顺序表传值 
	Print(L);  //打印顺序表
	cout<<"请输入删除元素"<<endl;
	cin>>x;	 //输入删除的元素x
	del_x(L,x);  //删除所有值为x的元素
	Print(L);  //再次打印输出
	return 0;
}

输出：

请输入顺序表长度
6
顺序表初始化完成
请传入数值
2 2 3 5 2 4
目前顺序表为：
2       2       3       5       2       4
请输入删除元素
2
目前顺序表为：
3       5       4

试题4/5：（王道2023数据结构综合应用题4/5）

从（有序）顺序表中删除值在s,t之间（要求s小于t），如果s和t的值不合理或顺序表为空，则显示出错信息并退出运行。

道理和题3差不多，只是要修改比较条件。这里假定顺序表不是有序的。

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

int del_x_st(SqList &L,int s,int t){
//删除所有值在s和t之间的元素
	if (s>t) cout<<"s和t的值非法"<<endl;
	if (L.length == 0) cout<<"顺序表为空"<<endl;
	int j = 0;  //j记录元素值在s与t之间的个数
	for(int i = 0; i < L.length; i++){
		if (L.data[i] >= s && L.data[i] <= t)
			j = j + 1;
		L.data[i+1 - j] = L.data[i+1];
	}
	L.length = L.length - j;
	return 0;
} 

int main(){
	int n,e,s,t;
	cout<<"请输入顺序表长度"<<endl;
	cin>>n;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n);	 //顺序表传值 
	Print(L);  //打印顺序表
	cout<<"请输入删除元素的下界"<<endl;
	cin>>s;	 //输入删除的元素下界s
	cout<<"请输入删除元素的上界"<<endl;
	cin>>t;	 //输入删除的元素上界t
	del_x_st(L,s,t);  //删除所有值在s和t之间的元素
	Print(L);  //再次打印输出
	return 0;
}

输出：

请输入顺序表长度
6
顺序表初始化完成
请传入数值
2 2 3 5 4 3
目前顺序表为：
2       2       3       5       4       3
请输入删除元素的下界
3
请输入删除元素的上界
4
目前顺序表为：
2       2       5

试题6（王道2023数据结构综合应用题6）：

删除顺序表中所有重复元素

这道题就不能按照前3，4，5题写：以下是错误示例：

int del(SqList &L){
//删除所有重复元素
	if (L.length == 0) cout<<"顺序表为空"<<endl;
	int j = 0;  //j记录重复次数
	for(int i = 1; i < L.length; i++){
		if (L.data[i-1] == L.data[i])
			j = j + 1;
		L.data[i+1 - j] = L.data[i+1];
	}
	L.length = L.length - j;
	return 0;
}

这段代码的输出结果是这样的：

目前顺序表为：
1       2       2       3       3       4
目前顺序表为：
1       2       4

分析：当i=2的时候，data[1]和data[2]相等。j变为1，于是data[2]就改为3，此时顺序表变为1，2，3，3，3，4。相当于多引入了一次重复。这样本来原顺序表只有两次重复，现在变成了3次。

正确解法：

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

int del(SqList &L){
//删除所有重复元素
	if (L.length == 0) cout<<"顺序表为空"<<endl;
	int j = 1;  //j记录不重复的元素个数
	for(int i = 1; i < L.length; i++){
		if (L.data[i-1] != L.data[i])  //此时第i个元素不和前面元素重复
			j = j + 1;
		L.data[j-1] = L.data[i];  //把不重复的元素加到后面
	}
	L.length = j;
	return 0;
} 

int main(){
	int n,e,s,t;
	cout<<"请输入顺序表长度"<<endl;
	cin>>n;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n);	 //顺序表传值 
	Print(L);  //打印顺序表
	del(L);  //删除所有重复元素
	Print(L);  //再次打印输出
	return 0;
}

输出：

请输入顺序表长度
6
顺序表初始化完成
请传入数值
1 2 2 3 3 4
目前顺序表为：
1       2       2       3       3       4
目前顺序表为：
1       2       3       4

试题7（王道2023数据结构综合应用题7）：

将两个有序顺序表合并成一个有序顺序表

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

SqList Merge(SqList L1,SqList L2){
//将两个有序表合并成一个有序表
	if (L1.length == 0 ||L2.length == 0) cout<<"顺序表为空"<<endl;
	int i = 0, j = 0, k = 0;
	SqList L;
	L.length = L1.length + L2.length;
	while (i<=L1.length && j<=L2.length)
	{
		if (L1.data[i]<=L2.data[j])
		{
			L.data[k] = L1.data[i];
			i = i + 1;
			k = k + 1;
		}
		else
		{
			L.data[k] = L2.data[j];
			j = j + 1;
			k = k + 1;
		}
	}
	if (i=L1.length) {  //L1已比较完毕，把L2剩下的元素依次复制到L中
		for (; j < L2.length; j++)
		{
			L.data[k] = L2.data[j];
			k = k + 1;
		}
	}
	if (j=L2.length) {  //L2已比较完毕，把L1剩下的元素依次复制到L中
		for (; i < L1.length; i++)
		{	
			L.data[k] = L1.data[i];
			k = k + 1;
		}
	}
	return L;
} 

int main(){
	int n1, n2;
	cout<<"请输入顺序表L1长度"<<endl;
	cin>>n1;	 //输入数组的长度n
	SqList L1;
	InitList(L1);  //顺序表的初始化
	CreatList(L1,n1);	 //顺序表传值 
	Print(L1);  //打印顺序表
	cout<<"请输入顺序表L2长度"<<endl;
	cin>>n2;	 //输入数组的长度n
	SqList L2;
	InitList(L2);  //顺序表的初始化
	CreatList(L2,n2);	 //顺序表传值 
	Print(L2);  //打印顺序表
	Print(Merge(L1,L2));  //打印输出合并之后的顺序表
	return 0;
}

输出：

请输入顺序表L1长度
4
顺序表初始化完成
请传入数值
1 2 3 5
目前顺序表为：
1       2       3       5
请输入顺序表L2长度
4
顺序表初始化完成
请传入数值
2 3 6 8
目前顺序表为：
2       3       6       8
目前顺序表为：
1       2       2       3       3       5       6       8

试题8（王道2023数据结构综合应用题8）：

已知在一维数组A[m+n]中依次存放两个线性表(a1, a2, a3...am)和(b1, b2, b3...bn)，将数组中两个顺序表的位置互换。也就是把(b1, b2, b3...bn)放在(a1, a2, a3...am)的前面。

直接暴力求解：

#include<iostream>
#include<algorithm>

using namespace std;
#define MaxSize 10
#define ElemType int

//顺序表的建立 
typedef struct{
	int data[MaxSize];  //存储空间的基地址
	int length;  //当前长度 
}SqList;
	 
//顺序表的初始化
void InitList(SqList &L){
	L.length = 0;
	cout<<"顺序表初始化完成"<<endl; 
} 
		
//顺序表传值 
void CreatList(SqList &L,int n){
	cout<<"请传入数值"<<endl; 
	for(int i=0;i<n;i++){
		cin>>L.data[i];
		L.length++;
	}
}
	
//打印顺序表 
int Print(SqList L){
	cout<<"目前顺序表为："<<endl;
	if (L.length == 0){
	    return 0;
	}
	for (int k = 0; k < L.length; k++){  //输出顺序表 
	    cout<<L.data[k]<<"\t";	
	}
	cout<<endl;
}

SqList Merge(SqList &L,int m,int n){
//把两个顺序表交换顺序
	SqList L0;
	L0.length = m;
	for (int i = 0; i < m; i++)  //把第一个顺序表复制一份
	{
		L0.data[i] = L.data[i];
	}
	for (int i = 0; i < n; i++)  //把后面的复制到前面去
	{
		L.data[i] = L.data[m + i];
	}
	for (int i = 0; i < m; i++)  //然后把第一个顺序表再复制到后面
	{
		L.data[i+n] = L0.data[i];
	}
	return L;
} 

int main(){
	int n1, n2;
	cout<<"请输入顺序表L1长度"<<endl;
	cin>>n1;	 //输入数组的长度n
	cout<<"请输入顺序表L2长度"<<endl;
	cin>>n2;	 //输入数组的长度n
	SqList L;
	InitList(L);  //顺序表的初始化
	CreatList(L,n1+n2);	 //顺序表传值 
	Print(L);  //打印顺序表
	Print(Merge(L,n1,n2));  //打印输出交换之后的顺序表
	return 0;
}

输出：

请输入顺序表L1长度
3
请输入顺序表L2长度
4
顺序表初始化完成
请传入数值
1 2 3 4 5 6 7
目前顺序表为：
1       2       3       4       5       6       7
目前顺序表为：
4       5       6       7       1       2       3
北京地铁1号线
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
quartz-2.2.3-官方文档数据及PDM表结构.zip
06-23
综上所述，"quartz-2.2.3-官方文档数据及PDM表结构.zip"文件包含的内容将帮助开发者深入理解Quartz的各个方面，从基本概念到高级特性，为实际项目中的任务调度提供全面指导。通过学习和应用这些知识，可以提高应用...
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
28.顺序表练习题目（2）（2023王道数据结构2.2.3节9-14题）
qq_54708219的博客
09-17 86
如果数组中存在大于一半的相同元素，首先假设第一个元素为主元素的候选元素【统计个数为1】，如果目前元素统计的个数大于0，遇到相同的数字——个数加1，不同的数字——个数减1；例如，若序列S1=(11, 13, 15, 17, 19)，则S1的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。推广之，去掉等量的最高和最低的元素之后，序列的中位数不会发生变化。注意：如果折半查找找不到的话，最后退出while循环的时候，low指针指向的是高于x的第一个元素，high指针指向的是低于x的最后一个元素。
王道22数据结构课后习题（第二章2.2.3）
qq_50679120的博客
03-30 2655
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
24王道+22小状元数据结构代码题——第2章 线性表
qq_52957637的博客
06-28 321
24王道数据结构代码题——第2章 线性表
数据结构笔记(全)
señoritaw的博客
04-25 2941
线性表：是具有相同数据类型的 n 个数据元素的有限序列。(Eg:所有的整数按递增次序排列，不是顺序表，因为所有的整数是无限的)其中n为表长，当n=0时线性表是一个空表。若用L表示一个线性表，则是线性表中的第i个元素，称为线性表中的位序是表头元素;是表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱;除最后一个元素外，每个元素有且仅有一个直接后继2.1.2 线性表的基本操作InitList(&L)：初始化表。构造一个空的线性表 L，分配内存空间。
2.2.3 数据透视表的简单介绍.mp4
09-17
数据透视表的简单介绍
2.2.3　城市空间结构　课时练习.doc
08-19
以下是对【标题】"2.2.3　城市空间结构　课时练习.doc"和【描述】"2.2.3　城市空间结构　课时练习.doc"中所包含知识点的详细解释： 1. **城市地域功能分区**：城市中的不同区域根据其主要功能可分为商业区、工业区...
nacos-2.2.3.tar.gz
03-08
在本案例中，我们关注的是 "nacos-2.2.3.tar.gz" 这个版本的 Nacos 在 Linux 环境下的部署和使用。 `nacos-2.2.3.tar.gz` 是一个经过 gzip 压缩的 tar 归档文件，广泛应用于 Linux 系统中。这种格式便于在不同的 ...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 913
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 219
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 205
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 291
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 604
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
2766. 重新放置石块 Medium
珞米的博客
07-24 525
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 273
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 919
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 245
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
F1C200s数据表手册修订版1.0
2.2.3 SD/MMC接口 F1C200s的SD/MMC接口用于扩展存储容量，能够支持SD卡和MMC卡等存储设备。 2.3 系统外围 F1C200s的系统外围包括计时器、国际、监护病房、DMA和PWM等方面。 2.3.1 计时器 F1C200s的计时器用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北京地铁1号线

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值