顺序表的增、删、改、查

已于 2024-02-27 19:51:12 修改
阅读量1.1k 收藏 30
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构
于 2024-01-24 21:16:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71964451/article/details/135820752
版权

小伙伴们好，学完C语言，就要开始学数据结构了，数据结构也是非常重要的，今天我们主要来学习在数据结构中最常用的增删改查操作。话不多说，一起来学习吧

1.数据结构相关概念

1.什么是数据结构？

数据结构是由“数据”和“结构”两词组合⽽来。
什么是数据？常⻅的数值1、2、3、4.....、教务系统⾥保存的⽤⼾信息（姓名、性别、年龄、学历等等）、⽹⻚⾥⾁眼可以看到的信息（⽂字、图⽚、视频等等），这些都是数据。
什么是结构？
当我们想要使⽤⼤量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独⽴的变量对于程序来说，可读性⾮常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的⽅式。
想要找到草原上名叫“咩咩”的⽺很难，但是从⽺圈⾥找到1号⽺就很简单，⽺圈这样的结构有效将
⽺群组织起来。
概念：数据结构是计算机存储、组织数据的⽅式。数据结构是指相互之间存在⼀种或多种特定关系
的数据元素的集合。数据结构反映数据的内部构成，即数据由那部分构成，以什么⽅式构成，以及数据元素之间呈现的结构。
总结：
1）能够存储数据（如顺序表、链表等结构）
2）存储的数据能够⽅便查找
2、为什么需要数据结构？
如图中所⽰，不借助排队的⽅式来管理客⼾，会导致客⼾就餐感受差、等餐时间⻓、餐厅营业混乱等情况。同理，程序中如果不对数据进⾏管理，可能会导致数据丢失、操作数据困难、野指针等情况。通过数据结构，能够有效将数据组织和管理在⼀起。按照我们的⽅式任意对数据进⾏增删改查等操作。
最基础的数据结构：数组。
【思考】有了数组，为什么还要学习其他的数据结构？
假定数组有10个空间，已经使⽤了5个，向数组中插⼊数据步骤：
求数组的⻓度，求数组的有效数据个数，向下标为数据有效个数的位置插⼊数据（注意：这⾥是
否要判断数组是否满了，满了还能继续插⼊吗）.....
假设数据量⾮常庞⼤，频繁的获取数组有效数据个数会影响程序执⾏效率。
结论：最基础的数据结构能够提供的操作已经不能完全满⾜复杂算法实现。

2.顺序表

2.1 顺序表的概念及结构

1.线性表

线性表（ linear list ）是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中⼴泛使
⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，
线性表在物理上存储时，通常以数组和链式结构的形式存储。
案例：蔬菜分为绿叶类、⽠类、菌菇类。线性表指的是具有部分相同特性的⼀类数据结构的集合
顺序表：逻辑结构是线性的，物理结构是连续的
2.2顺序表分类
• 顺序表和数组的区别
        ◦ 顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝
• 顺序表分类
        ◦ 静态顺序表
                概念：使用定长数组存储元素
静态顺序表缺陷：空间给少了不够⽤，给多了造成空间浪费
◦ 动态顺序表

3.动态顺序表的实现

首先我们要创建3个文件，分别是1个头文件SeqList.h，2个源文件SeqList.c和test.c.它们的作用分别是：

SeqList.h：头文件的作用是定义顺序表的结构，顺序表要实现的接口/方法

SeqList.c:具体实现顺序表里定义的接口/方法

test.c:测试动作：测试顺序表

OK,文件准备好了，现在就开始写代码了

首先我们要给数据类型起一个别名，为什么呢？假设我们写了1000行代码，里面使用到了非常多的数据类型，假定全是int类型，有一天别人让你把一些int类型改成char类型，那么你就要一个一个的把int改成char，虽然你们想说不是可以一键替换吗，这个方法也可以，但是不是全部都要改成char类型，这不是最佳的方法。所以作为程序员我们要专业一点，于是就要给自定义的给int类型取个别名，取什么名字可以自己决定，专业的人就要干专业的事。比如说我们可以改成这个

typedef int SLDataType;

这样就能解决上面的问题了，你想要改成什么数据类型，就只需要把int改成你要的类型。是不是很方便呢。

我们首先要做一些准备工作，方便为接下来的操作做准备

3.1定义结构体
typedef struct SeqList  
{
	SLDataType* arr;//存储数据的底层结构
	int capacity;   //记录顺序表的空间大小
	int size;       //记录顺序表当前有效的数据个数
}SL;

细心的小伙伴们发现我也给结构体取了一个别名SL，这样也是为了方便接下来的使用。

当然你也可以这样写

struct SeqList  
{
	SLDataType* arr;//存储数据的底层结构
	int capacity;   //记录顺序表的空间大小
	int size;       //记录顺序表当前有效的数据个数
};

typedef struct SeqList SL;
3.2 结构体的初始化和销毁

在SeqList.h文件中定义初始化和销毁的函数，具体实现方法要在SeqList.c文件中实现

可能有人会这么写

这样写会报错，因为这样写是传值调用，而我们要传地址。所以正确写法是下面这种

void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLInit(SL* ps)//ps是形参
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

我们可以测试一下

好了，这么写没有问题。

好了，准备工作基本完成。正式开始我们的增删改查吧。

3.3插入数据：尾插和头插

首先要分析空间够不够。

空间足够：直接插入，假设插入的数据是x=6，即arr[size]=6，size是有效数据的下一个

空间不够：扩容。那么扩容的方法有哪些呢？

  1. 一次扩充一个空间：插入一个元素还不会造成空间浪费
  2. 一次扩容固定个大小空间（10，100……）
  3. 成倍数的增加（1.5倍，2倍）

第一个方法虽然不会造成空间的浪费，但是由于扩容的频率太高会造成程序效率低下

第二个方法空间给小了，还需要继续扩容，也会造成程序效率低下，给大了又可能会造成空间的浪费。

这里我推荐第三个方法，成2倍数的增加（依次扩大4，8，16，32……个空间）数据插入的越多，扩容的空间越来越大，数据和扩容量成正相关，浪费也不会造成太多的浪费。扩容的方法是使用realloc函数，realloc函数使用方法可以看我这篇文章http://t.csdnimg.cn/rwb7g

头插的难点是如何将数据往后挪动

如果直接在第一个位置插入数据，那么就会造成数据丢失 ！所以就要从后往前挪动，把第i个位置移到第i-1的位置处。

由于头插和尾插都要判断是否扩容，所以我们要将扩容空间单独写一个函数，这样空间不够的时候可以直接调用

扩容函数

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//扩容成倍数增加，每次扩容2倍
		//ps->arr=(SLDataType*)realloc(ps->arr,2 * ps->capacity)
		//不能这样写，因为初始化capacity为0
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));//要乘以数据类型的大小
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);//扩容失败直接中断程序
		}
		//扩容成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
//顺序表的头部/尾部的插入
void SLPushBack(SL* ps,SLDataType x);//尾插
void SLPushFront(SL* ps, SLDataType x);//头插
void SLPushBack(SL* ps, SLDataType x)//尾插
{
	assert(ps != NULL);

	//空间不够，扩容。当capacity <= size时
	SLCheckCapacity(ps);
	//空间足够，直接插入。当capacity>size时
	ps->arr[ps->size++] = x;
	//ps->size++;
}

void SLPushFront(SL* ps, SLDataType x)//头插
{
	assert(ps != NULL);

	//判断是否扩容
	SLCheckCapacity(ps);
	//旧数据往后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

测试尾插

测试头插

打印函数

void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

ok,扩容没有问题，这样就说明增加操作没有问题了。另外不能传入一个空值，所以要进行assert断言。

3.4 删除数据：头删和尾删

删除数据要分两种情况：顺序表为空，则不能进行删除；顺序表不为空，尾删则删除最后一个有效数据，size--。头删就要删除第一个数据，然后把后面的数据往前挪动

//顺序表的头部/尾部的删除
void SLPoBack(SL* ps);
void SLPoFront(SL* ps);
//顺序表的头部/尾部的删除
void SLPoBack(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size);//顺序表为空不能进行删除

	//顺序表不为空
	ps->size--;
}

void SLPoFront(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size);//顺序表为空不能进行删除

	//不为空执行挪动操作,后面的数据往前挪动一位
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
测试尾删

测试头删

 3.5 指定位置删除或者插入数据

指定位置之前插入数据

void SLInsert(SL* ps, int pos, SLDataType x);
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//pos不能超过当前顺序表的有效数据
	SLCheckCapacity(ps);//检查是否有空间可以插入

	//pos及之后的数据往后挪动一位，pos空出来,size++
	for (int i=ps->size; i>pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

 测试：

删除指定位置的数据

void SLErase(SL* ps, int pos);
void SLErase(SL* ps, int pos)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos < ps->size);//只能对size之前的数据进行删除
	
	//pos以后的数据往前挪动一位
	for (int i=pos; i<ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

测试

3.6 查找数据
int SLFind(SL* ps, SLDataType x);
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

测试

3.7 修改数据
void SLRevise(SL* ps,int pos,SLDataType x);

void SLRevise(SL* ps,int pos,SLDataType x)
{
	if (pos >= ps->size)
		printf("修改失败!要修改的元素不存在\n");
	else
	{
		printf("修改成功,新数据为：");
		ps->arr[pos] = x;
	}
}

测试 

4.完整代码呈现

 SeqList.h

#pragma once
//头文件的作用是定义顺序表的结构，顺序表要实现的接口/方法
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//动态顺序表
//typedef Info SLDataType;

typedef int SLDataType;
typedef struct SeqList  //方法一
{
	SLDataType* arr;//存储数据的底层结构
	int capacity;   //记录顺序表的空间大小
	int size;       //记录顺序表当前有效的数据个数
}SL;

//typedef struct SeqList SL;   //方法二

//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);

//顺序表的头部/尾部的插入
void SLPushBack(SL* ps,SLDataType x);//尾插
void SLPushFront(SL* ps, SLDataType x);//头插

//顺序表的头部/尾部的删除
void SLPoBack(SL* ps);
void SLPoFront(SL* ps);

//指定位置之前插入数据
//删除指定位置的数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

//修改数据
void SLRevise(SL* ps,int pos,SLDataType x);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
//具体实现顺序表里定义的接口/方法
#include"SeqList.h"
//初始化和销毁
void SLInit(SL* ps)//ps是形参
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//扩容成倍数增加，每次扩容2倍
		//ps->arr=(SLDataType*)realloc(ps->arr,2 * ps->capacity)
		//不能这样写，因为初始化capacity为0
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));//要乘以数据类型的大小
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);//扩容失败直接中断程序
		}
		//扩容成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

//顺序表的头部/尾部的插入
void SLPushBack(SL* ps, SLDataType x)//尾插
{
	assert(ps != NULL);

	//空间不够，扩容。当capacity <= size时
	SLCheckCapacity(ps);
	//空间足够，直接插入。当capacity>size时
	ps->arr[ps->size++] = x;
	//ps->size++;
}

void SLPushFront(SL* ps, SLDataType x)//头插
{
	assert(ps != NULL);

	//判断是否扩容
	SLCheckCapacity(ps);
	//旧数据往后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

//顺序表的头部/尾部的删除
void SLPoBack(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size);//顺序表为空不能进行删除

	//顺序表不为空
	ps->size--;
}

void SLPoFront(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size);//顺序表为空不能进行删除

	//不为空执行挪动操作,后面的数据往前挪动一位
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//pos不能超过当前顺序表的有效数据
	SLCheckCapacity(ps);

	//pos及之后的数据往后挪动一位，pos空出来,size++
	for (int i=ps->size; i>pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

//删除指定位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos < ps->size);//只能对size之前的数据进行删除
	
	//pos以后的数据往前挪动一位
	for (int i=pos; i<ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//在顺序表中查找x
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//修改数据
void SLRevise(SL* ps,int pos,SLDataType x)
{
	if (pos >= ps->size)
		printf("修改失败!要修改的元素不存在\n");
	else
	{
		printf("修改成功,新数据为：");
		ps->arr[pos] = x;
	}
}

void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
//测试动作：测试顺序表
#include"SeqList.h"

void slTest01()
{
	SL sl;
	SLInit(&sl);//传址调用

	//测试尾插
	/*SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);	*///1 2 3 4
	//SLPushBack(&sl, 5);
	//SLPrint(&sl);	//1 2 3 4



	测试头插
	/*SLPushFront(&sl, 5);
	SLPushFront(&sl, 6);
	SLPushFront(&sl, 7);
	SLPrint(&sl);*/

	//测试尾删
	/*SLPoBack(&sl);
	SLPoBack(&sl);
	SLPrint(&sl);*/

	//测试头删
	/*SLPoFront(&sl);
	SLPoFront(&sl);
	SLPrint(&sl);*/

	//测试指定位置插入
	//SLInsert(&sl, 0, 100);
	//SLPrint(&sl);
	//SLInsert(&sl, sl.size, 200);//在size位置插入数据
	//SLPrint(&sl);

	//测试删除指定位置的数据
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLErase(&sl, 2);
	SLPrint(&sl);
	/*SLErase(&sl, sl.size - 1);
	SLPrint(&sl);*/
    
    //修改数据
	SLRevise(&sl, 1, 5);
	SLPrint(&sl);
	SLRevise(&sl, 4, 5);
}

void slTest02()
{
	SL sl;
	SLInit(&sl);//传址调用

	//测试尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	//测试查找
	int ret = SLFind(&sl, 2);
	if (ret < 0)
	{
		printf("数据不存在，查找失败！");
	}
	else {
		printf("数据找到了，在下标为%d的位置\n", ret);
	}
}

//void slTest03()
//{
//	SL sl;
//	SLInit(&sl);
//	SLDestroy(&sl);
//}

int main()
{
	//slTest01();
	slTest02();
	//slTest03();
	return 0;
}

终于大功告成了，感谢小伙伴们能看到这里，说明你们都想学好C语言，小伙伴们，我们一起加油。根据这个增删查改，我们就可以写出一个小程序了，那么就是通讯录的实现。等我有时间了我也会把通讯录的实现分享出来，供大家学习参考。感谢各位观看。

顺序表的删除
weixin_44552244的博客
05-18 4267
开发工具与关键技术：Visual Studio / 元素按顺序存放地址连续 作者：郑名方 撰写时间：2020年5月18日 大家还记得顺序表的特点：所有的元素紧密保存在一起/元素按顺序存放地址连续。 我们本次所说的是顺序表的删除。 假设他们的地址是连续的是连续的空间。如果我们想删除其中一个元素，那么就存在一个问题，删除顺序表的一个元素不难，但是空出来的位置就让它在那里吗？答案是不可以的。因为那样就违背了顺序表的原则。 顺序表例如说顺序表0~7，假设我们想要删除3这个位置的元素也就是说对应3位置的元素要被删除掉
Java基础||顺序表的增删改查
weixin_48454152的博客
08-17 416
插入操作的时间复杂度：最好情况O(1),最坏情况O(n)，平均情况O(n)对数据合法性进行效验(头插 index=0；尾插index=size）对于顺序表，插入数据依次后移（从后向前）；删除数据依次前移（从前往后）//从后向前依次移动元素，直到i = index指向位置。在插入元素之前，先进行判断，插入的位置是不是在有效范围内。对于空间不够的情况，进行扩容。...
数据结构--顺序表的创建和增删改查操作
KBDYD1010的博客
09-19 657
通过编写学生管理系统掌握顺序表的创建、增删改查等功能
SeqList (顺序表增删改查).c
05-15
初学数据结构，顺序表的增删改查自己还不是很熟练，将自己的学习记录在CSDN社区。希望在编程道路的小伙伴共同进步
数据结构-基于C语言实现线性顺序表的增删改查+排序，合表操作.rar
08-11
本资料包提供了一个基于C语言实现线性顺序表的实例，包括增删改查以及排序和合表操作。 线性顺序表是一种特殊的数组，它的元素按线性顺序排列，可以通过下标访问任意位置的元素。在C语言中，我们通常使用一维数组来...
顺序表增删改查的实现技巧与分析
4. 异常处理：在顺序表的增删改查操作中，需要注意异常情况的处理，如插入位置不存在、删除位置无效等，应当通过抛出异常或者返回错误码来通知调用者。 5. 缓存局部性原理：顺序表的连续存储特性符合计算机缓存局部...
顺序表的增删改查，顺序表
10-10
在编程中，顺序表通常用数组来实现，因为数组提供了直接访问任意位置元素的能力，使得增删改查等基本操作变得简单高效。下面我们将深入探讨顺序表的实现、其特点以及增删改查的具体操作。 首先，顺序表是由一组相同...
顺序表的插入删除操作
12-14
顺序表的插入删除操作（源程序通过上机测试）。
顺序表的增加删除
echoerror的博客
05-19 508
#include #define maxsize 10 void insertelem(int sqlist[],int *len,int i,int x){ int t; if(*len==maxsize||i*len+1){//非法提示 printf("this insert is illegal"); return; } for(t=*len;t>=i-1;t--){
数据结构之顺序表的删除
m0_52201270的博客
12-15 1063
数据结构之链表的删除
C#增、删、查、改
FJC520168的博客
08-20 641
C#对于数据处理方式最多的就是查询、新增、修改、删除。以这四个方面为主做数据的处理。 一、 查询 查询方法使用是最多的，在其它三个方法中也会使用。只要是要对数据做处理首先需要查询到数据。 查询的方式有很多种： 1.单表查询 这是一个简单的单表查询，创建一个List表类型的变量接收通过linq语句查询出的数据。linq的查询通过关键字（from 自定义表名 in 数据来源 select 需要查询的数据），从某个数据来源中查询数据。 结尾处ToList()代表返回列表形式的数据，还有其它几种常用的方法：Sing
[数据结构]顺序表的基本操作——删除
m0_64973566的博客
03-07 6713
……………………………………………………………………………… 以下内容注意int &e; &表示的是e是引用变量。此时，删除方法中的变量e和main函数中的变量e在内存中对应的是同一份数据。 若e不是引用型变量，则main函数中声明了一个局部于main函数的变量e，并且调用了删除函数，但由于这个参数e不再是引用型变量会导致删除方法中处理的e是main函数中变量e的复制品。尽管main函数和删除方法中的变量e名称一样，但在内存中对应的是两份不同的数据，...
顺序表插入和删除
jinghang2000的博客
11-13 1094
#define MaxSize 10 #include <stdio.h> typedef struct { int data[MaxSize]; int length; }SqList; //在L的位序i 插入元素e //void ListInsert(SqList &L, int i, int e){ // //i的合法值 [1,length+1] // for(int j=L.length; j>=i; j--) //将i个元素之后的元素后移 /.
7-7 顺序表（删除） (10 分)
LancasterLiu的博客
07-19 1538
7-7 顺序表（删除） (10 分) 已知一组数据，采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素 输入格式: 输入包含三行数据，第一行是表中元素个数，第二行是顺序表的各个元素，第三行是区间x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后，输出新的顺序表。(最后无空格) 样例 输入样例: 在这里给出一组输入。例如： 10 55 11 9 15 67 12 18 33 6 22 10 20 输出样例: 在这里给出相应的输出。例如： 55 9 67 3
顺序表增删改查源代码
最新发布
10-18
下面是一个简单的顺序表（单链表）的增删改查的伪代码示例： ```python class SequentialList: def __init__(self): self.data = [] # 插入元素 def insert(self, index, value): if index < 0 or index > ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值