【数据结构】顺序表增删查改（超详细）

已于 2024-05-14 18:31:03 修改
阅读量1.4k 收藏 17
点赞数 46
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2024-04-26 23:46:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74897518/article/details/138227716
版权

文章目录

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使
用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，

线性表在物理上存储时，通常以数组和链式结构的形式存储。
线性表

2.顺序表

2.1顺序表的定义及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
储。在数组上完成数据的增删查改。
顺序表一般可以分为：

2.1.1 静态顺序表：使用定长数组存储元素。

静态顺序表

2.1.2 动态顺序表：使用动态开辟的数组存储。

动态顺序表

小结

静态的顺序表的缺点很明显：空间给小了不够用，给大了会浪费，不实用。所以我们通常使用动态的顺序表，灵活性更高。

2.2顺序表的接口实现

新建一个工程（动态顺序表）

SeqList.h（顺序表的类型定义、接口函数声明、引用的头文件）
SeqList.c（顺序表接口函数的实现）
test.c（主函数、测试顺序表各个接口功能）

完整的代码放在后面（包括测试代码），这里就不会展示测试的效果图。大家可以自己别敲边按测试代码测试。注释会写的很详细的，么么😙
注意：size是数据个数，看做下标的话，他是最后一个数据的下一个位置

2.2.1顺序表初始化

//顺序表初始化
void SLInit(SL* psl)

{
	assert(psl);//断言一下防止传空指针进来
	psl->a = NULL;//初始顺序表为空
	psl->size = 0; //初始数据个数为0
	psl->capacity = 0;//初始空间容量为0，也可以给初始空间值
}

2.2.2顺序表打印

//顺序表打印
void SLPrint(const SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	//这里也不用去判断顺序表为不为空，因为为空就不会打印。
	for (int i = 0; i < psl->size; i++)//打印顺序表
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

2.2.3检查空间，如果满了，进行增容

注意：若传入realloc的指针为空指针(NULL)，则realloc函数的作用相当于malloc函数。

//检查空间，如果满了，进行增容
void SLCheckCapacity(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	if (psl->size == psl->capacity)//检查空间，满了就增容
	{
		int newcapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;//这里用了三字母词，就是如果capacity为0则赋一个4如果不为空则扩容自身的2倍
		SLDataType* tmp = (SLDataType*)realloc(psl->a, newcapacity * sizeof(SLDataType));//realloc扩容，开一个新指针去接收，万一没开辟成功，也不会影响原来的psl所指向的空间，有时候后面连续空间不够，会重新开辟一个新空间，地址也会改变。
		if (tmp == NULL)//判断是否开辟失败
		{
			perror("realloc");
			return;
		}
		psl->a = tmp;
		psl->capacity = newcapacity;//更新容量
	}
}

2.2.4顺序表尾插

//顺序表尾插
void SLPushBack(SL* psl, SLDataType x)
{

	assert(psl);//断言一下防止传空指针进来
	SLCheckCapacity(psl);//调用函数检查容量
	psl->a[psl->size] = x;//尾插数据
	psl->size++;//更新有效个数
}

2.2.5顺序表尾删

//顺序表尾删
void SLPopBack(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	psl->size--;//直接减少有效个数就ok了，访问不到了。
}

2.2.6顺序表头插

//顺序表头插
void SLPushPront(SL* psl, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	SLCheckCapacity(psl);//调用函数检查容量
	int end = psl->size - 1;//找尾
	while (end >= 0)//挪动数据
	{
		psl->a[end + 1] = psl->a[end];//这里要从后往前移
		end--;
	}
	psl->a[0] = x;//头插数据
	psl->size++;//更新有效个数

}

2.2.7顺序表头删

//顺序表头删
void SLPopPront(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	int begin = 1;//找头
	while (begin < psl->size)//挪动数据
	{
		psl->a[begin - 1] = psl->a[begin];//从前往后移动
		begin++;
	}
	psl->size--;//更新有效数据
}

2.2.8顺序表在下标pos位置插入x

// 顺序表在下标pos位置插入x
void SLInsert(SL* psl, int pos, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	assert(pos >= 0 && pos <= psl->size);//顺序表是连续的，所以要确保pos的下标有效
	SLCheckCapacity(psl);//调用函数检查容量
	int end = psl->size - 1;//找尾
	while (end >= pos)//挪动数据
	{
		psl->a[end + 1] = psl->a[end];//从后往前移动
		end--;
	}
	psl->a[pos] = x;//在下标pos处插入数据
	psl->size++;//更新有效数据

}

2.2.9 顺序表删除下标pos位置的值

// 顺序表删除下标pos位置的值
void SLErase(SL* psl, int pos)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	assert(pos >= 0 && pos <psl->size);//顺序表是连续的，所以要确保pos的下标有效
	int begin = pos + 1;//找pos后一个位置
	while (begin < psl->size)//挪动数据
	{
		psl->a[begin - 1] = psl->a[begin];//从前往后移动
		begin++;
	}
	psl->size--;//更新有效数据
}

2.2.10 顺序表查找x

//顺序表查找x
int SLFind(const SL* psl, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	for (int i = 0; i < psl->size; i++)//遍历查找
	{
		if (psl->a[i] == x)
		{
			return i;//相等则反回该值在数组中的下标
		}
	}
	return -1;//数组中没有则返回-1
}

2.2.11 修改顺序表下标pos位置的值

void SLModify(SL* psl, int pos, SLDataType x)
{
	assert(psl);  //断言一下防止传空指针进来
	assert(psl->size > 0); //顺序表不能为空
	assert(pos >= 0 && pos < psl->size); //顺序表是连续的，所以要确保pos的下标有效

	psl->a[pos] = x;  //修改pos下标处对应的数据
}

2.2.12 查看顺序表中有效数据个数

可能大家会有一个疑问，我在主函数里面直接通过定义的结构体变量直接访问就好了呀，为啥还要弄一个函数呢？
在数据结构中有一个约定，如果要访问或修改数据结构中的数据，不要直接去访问，要去调用它的函数来访问和修改，这样更加规范安全，也更方便检查是否出现了越界等一些错误情况。
越界不一定报错，系统对越界的检查是一种抽查
越界读一般是检查不出来的
越界写如果是修改到标志位才会检查出来
（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）

int SLSize(const SL* psl)
{
	assert(psl);  //断言一下防止传空指针进来

	return psl->size;
}

2.2.13 顺序表销毁

//顺序表销毁
void SLDestory(SL* psl)
{
	assert(psl); //断言一下防止传空指针进来
	if (psl->a != NULL)//判断如果为空则不用管，不为空则手动释放
	{
		free(psl->a);//释放动态开辟的空间
		psl->a = NULL;//置空
		psl->size = psl->capacity = 0;//全部置为0
	}
}

完整代码（包括测试代码）

SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//顺序表的动态储存
typedef int SLDataType;//给类型重命名，方便后续更改类型
typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	int size;//有效空间个数
	int capacity;//容量空间的大小
}SL;


//顺序表初始化
void SLInit(SL* psl);
//顺序表打印
void SLPrint(const SL* psl);
//检查空间，如果满了，进行增容
void SLCheckCapacity(SL* psl);
//顺序表尾插
void SLPushBack(SL* psl, SLDataType x);
//顺序表尾删
void SLPopBack(SL* psl);
//顺序表头插
void SLPushPront(SL* psl, SLDataType x);
//顺序表头删
void SLPopPront(SL* psl);
// 顺序表在下标pos位置插入x
void SLInsert(SL* psl, int pos, SLDataType x);
// 顺序表删除下标pos位置的值
void SLErase(SL* psl, int pos);
//顺序表查找x
int SLFind(const SL* psl, SLDataType x);
//修改顺序表下标pos位置的值
void SLModify(SL* psl, int pos, SLDataType x);
//查看顺序表中有效数据个数
int SLSize(const SL* psl);
// 顺序表销毁
void SLDestory(SL* psl);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

//顺序表初始化
void SLInit(SL* psl)

{
	assert(psl);//断言一下防止传空指针进来
	psl->a = NULL;//初始顺序表为空
	psl->size = 0; //初始数据个数为0
	psl->capacity = 0;//初始空间容量为0，也可以给初始空间值
}

//顺序表打印
void SLPrint(const SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	//这里也不用去判断顺序表为不为空，因为为空就不会打印。
	for (int i = 0; i < psl->size; i++)//打印顺序表
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

//检查空间，如果满了，进行增容
void SLCheckCapacity(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	if (psl->size == psl->capacity)//检查空间，满了就增容
	{
		int newcapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		//这里用了三字母词，就是如果capacity为0则赋一个4如果不为空则扩容自身的2倍
		SLDataType* tmp = (SLDataType*)realloc(psl->a, newcapacity * sizeof(SLDataType));
		//realloc扩容，开一个新指针去接收，万一没开辟成功，也不会影响原来的psl所指向的空间，有时候后面连续空间不够，会重新开辟一个新空间，地址也会改变。
		if (tmp == NULL)//判断是否开辟失败
		{
			perror("realloc");
			return;
		}
		psl->a = tmp;
		psl->capacity = newcapacity;//更新容量
	}
}

//顺序表尾插
void SLPushBack(SL* psl, SLDataType x)
{

	assert(psl);//断言一下防止传空指针进来
	SLCheckCapacity(psl);//调用函数检查容量
	psl->a[psl->size] = x;//尾插数据
	psl->size++;//更新有效个数
}

//顺序表尾删
void SLPopBack(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	psl->size--;//直接减少有效个数就ok了，访问不到了。
}

//顺序表头插
void SLPushPront(SL* psl, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	SLCheckCapacity(psl);//调用函数检查容量
	int end = psl->size - 1;//找尾
	while (end >= 0)//挪动数据
	{
		psl->a[end + 1] = psl->a[end];//这里要从后往前移
		end--;
	}
	psl->a[0] = x;//头插数据
	psl->size++;//更新有效个数

}

//顺序表头删
void SLPopPront(SL* psl)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	int begin = 1;//找头
	while (begin < psl->size)//挪动数据
	{
		psl->a[begin - 1] = psl->a[begin];//从前往后移动
		begin++;
	}
	psl->size--;//更新有效数据
}

// 顺序表在下标pos位置插入x
void SLInsert(SL* psl, int pos, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	assert(pos >= 0 && pos <= psl->size);//顺序表是连续的，所以要确保pos的下标有效
	SLCheckCapacity(psl);//调用函数检查容量
	int end = psl->size - 1;//找尾
	while (end >= pos)//挪动数据
	{
		psl->a[end + 1] = psl->a[end];//从后往前移动
		end--;
	}
	psl->a[pos] = x;//在下标pos处插入数据
	psl->size++;//更新有效数据

}

// 顺序表删除下标pos位置的值
void SLErase(SL* psl, int pos)
{
	assert(psl);//断言一下防止传空指针进来
	assert(psl->size > 0);//顺序表不能为空，防止删空
	assert(pos >= 0 && pos < psl->size);//顺序表是连续的，所以要确保pos的下标有效
	int begin = pos + 1;//找pos后一个位置
	while (begin < psl->size)//挪动数据
	{
		psl->a[begin - 1] = psl->a[begin];//从前往后移动
		begin++;
	}
	psl->size--;//更新有效数据
}


//顺序表查找x
int SLFind(const SL* psl, SLDataType x)
{
	assert(psl);//断言一下防止传空指针进来
	for (int i = 0; i < psl->size; i++)//遍历查找
	{
		if (psl->a[i] == x)
		{
			return i;//相等则反回该值在数组中的下标
		}
	}
	return -1;//数组中没有则返回-1
}



//修改顺序表下标pos位置的值
void SLModify(SL* psl, int pos, SLDataType x)
{
	assert(psl);  //断言一下防止传空指针进来
	assert(psl->size > 0); //顺序表不能为空
	assert(pos >= 0 && pos < psl->size); //顺序表是连续的，所以要确保pos的下标有效

	psl->a[pos] = x;  //修改pos下标处对应的数据
}

// 查看顺序表中有效数据个数
int SLSize(const SL* psl)
{
	assert(psl);  //断言一下防止传空指针进来

	return psl->size;
}

//顺序表销毁
void SLDestory(SL* psl)
{
	assert(psl); //断言一下防止传空指针进来
	if (psl->a != NULL)//判断如果为空则不用管，不为空则手动释放
	{
		free(psl->a);//释放动态开辟的空间
		psl->a = NULL;//置空
		psl->size = psl->capacity = 0;//全部置为0
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

void SLtest1()
{
	SL sl;
	SLInit(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	//SLPopBack(&sl);
	SLPrint(&sl);
	SLDestory(&sl);

}

void SLtest2()
{
	SL sl;
	SLInit(&sl);
	SLPrint(&sl);

	SLPushPront(&sl, 1);
	SLPushPront(&sl, 2);
	SLPushPront(&sl, 3);
	SLPushPront(&sl, 4);
	SLPrint(&sl);
	SLPopPront(&sl);
	SLPopPront(&sl);
	SLPopPront(&sl);
	SLPopPront(&sl);
	//SLPopPront(&sl);
	SLPrint(&sl);
	SLDestory(&sl);

}
void SLtest3()
{
	SL sl;
	SLInit(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 9);
	SLPrint(&sl);
	SLInsert(&sl, 4, 70);
	SLInsert(&sl, 0, 70);
	//SLInsert(&sl, 11, 70);
	//SLInsert(&sl, 13, 70);
	SLPrint(&sl);
	SLDestory(&sl);

}

void SLtest4()
{
	SL sl;
	SLInit(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPrint(&sl);
	SLErase(&sl, 0);
	SLPrint(&sl);
	SLErase(&sl, 0);
	SLPrint(&sl);
	SLErase(&sl, 0);
	SLPrint(&sl);
	//SLErase(&sl, 0);
	//SLPrint(&sl);
	SLDestory(&sl);



}

void SLtest5()
{
	SL sl;
	SLInit(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 9);
	SLPrint(&sl);


	int  pos = SLFind(&sl, 6);
	printf("%d \n", pos);
	SLModify(&sl, pos, 90);
	SLPrint(&sl);


	int size = SLSize(&sl);
	printf("%d \n", size);

	SLDestory(&sl);

}

int main()
{
	SLtest3();
	return 0;
}

总结

顺序表的优点：
（1）物理内存连续，支持下标随机访问O（1）
（2）尾插尾删很方便
顺序表的缺点：
（1）头部中间插入和删除效率低，通常须移动数据O(N)
（2）空间不够需要扩容，扩容有一定的消耗，且可能存在一定的空间浪费

会唱歌的小黄李
关注
  • 46
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
数据结构之顺序表的位序删除
m0_52201270的博客
12-15 541
数据结构之链表的位序删除
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
【数据结构1】顺序表的删除
zzynb666的博客
01-20 333
1.题目： 2.思路： （1）数组：这个思路实际上是有问题的，他对本题的数据输入是正确的，因为本题中的数组 b[ ]和c[ ]相同的元素是在同一个位置的，所以每次比较完之后，如果不同，直接i++,j++。但如果给的数据是：1 2 3 4 和1 3 4这样相同的元素不在同一个下标的情况就错了 void array() { int i,j; for(i = j = 0; i < n,j < p; i++,j++) { if(b[i] == c[j]) { for(in.
推免复习-数据结构-顺序表删除
weixin_39663419的博客
07-19 153
#include<iostream> using namespace std; int a[10]={35,12,24,42}; int n=4; void del(int i) { for(int j=i-1;j<n-1;j++) { a[j]=a[j+1]; } n--; } int main() { del(1); del(2); ...
【数据结构】NOJ003 顺序表的删除
夏至是个程序媛
04-02 865
题目：在数组a中，删去那些b和c的共同元素 方法： 设数组a、b、c的下标分别为i、j、k 从数组b和c的后面往前找，如果找到相同元素x 就从数组a的后面往前找这个元素x 如果找到了，删除x 如果没找到，就继续遍历数组b和c 直到i、j、k有一个为负为止 从后往前找的原因是，感觉这样移动的元素会少一点 在算法中，时刻要防止a[-1]这种情况的出现，也就是始终要检查下标是否越界（虽然测例里貌似没有这...
数据结构 — 2.顺序表删除问题
PeersLee的博客
10-27 1463
【问题描述】已知A,B和C为三个非递减有序的线性表,现要求对A表做如下操作:删去那些既在B表中出现又在C表中出现的元素.试对顺序表编写实现上述操作的算法(注意题中并没有特别指明同一表中的元素值各不相同).  注意此题用顺序表编写程序. 【输入形式】第一行为A表,第二行为B表,第三行为C表,分别以-1结束 【输出形式】删除后的A表 【样例输入】1 3 5 5 7 -1
数据结构与算法之顺序表的增删查改
07-03
本文将深入探讨顺序表的增删查改操作，帮助你更好地理解和应用这一基础知识。 顺序表，顾名思义，是指元素在内存中按照线性顺序存储的表格。它通常是在数组基础上实现的，数组的每个元素代表表中的一个数据项。由于...
顺序表的增删查改以及拼接操作SqList.cpp
11-28
顺序表的增删查改以及拼接操作
数据结构顺序表的实现方式.docx
11-26
数据结构顺序表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是...
顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法.zip
08-16
在本压缩包中，我们重点关注了三种类型的线性表：顺序表、链表和双链表，以及它们的增删查改操作和链表逆置等常见算法。 顺序表是一种最简单的线性表实现，它在内存中是连续存储的，可以通过数组来表示。对于顺序表...
[数据结构]顺序表的基本操作——删除
m0_64973566的博客
03-07 6546
……………………………………………………………………………… 以下内容注意int &e; &表示的是e是引用变量。此时，删除方法中的变量e和main函数中的变量e在内存中对应的是同一份数据。 若e不是引用型变量，则main函数中声明了一个局部于main函数的变量e，并且调用了删除函数，但由于这个参数e不再是引用型变量会导致删除方法中处理的e是main函数中变量e的复制品。尽管main函数和删除方法中的变量e名称一样，但在内存中对应的是两份不同的数据，...
顺序表的删除
qq_48795733的博客
07-29 592
按位序删除 + 按下标删除
数据结构--顺序表的建议和删除
sifangege的博客
05-30 1109
顺序表的建立和删除 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define ERROR 0 #define ElemType int #define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/ typedef struct { ElemType elem[M...
顺序表的插入和删除（数据结构）
热门推荐
shoushou_的博客
07-23 2万+
1.问题描述 顺序表的插入和删除是数据结构中比较基础的，在插入部分要能够做到在数组头部插入数据，在尾部插入数据，以及在指定位置插入指定数据。在删除部分要能够做到删除尾部数据，删除头部数据，删除指定位置的数据。 2.问题分析 在对象中设置一个属性size来表示数组中数据的长度，同时自然也少不了一个属性是数组。一般来将，给数组尾部插入一个数据或者删除数组尾部的数据比较简单，直接把下标为size++或者...
【数据结构】顺序表(SeqList)（增、删、查、改）详解
Elena's Blog
07-27 2986
在数据结构中，如果要访问或者修改数据结构中的数据不要直接访问，而是应该去调用它的函数来访问和修改，这样会更加规范和安全，也更方便检查出是否出现了越界等错误情况。数组越界是不一定报错的，系统对越界的检查是设岗检查。越界读（读了不属于自己的数据），一般是检查不出来的，往往并不会造成内存奔溃。越界写（缓冲区溢出）如果是修改到标志位才会被检查出来，会造成数据破坏，严重会造成内存奔溃。（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）
数据结构 顺序表的插入、删除与查找基本操作
lesileqin的博客
11-25 4035
#include&lt;iostream&gt; #include&lt;string&gt; #define MAXSIZE 100 //存储空间初始分配量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 using namespace std; typedef struct { int data[MAXSIZE...
【数据结构】顺序表（Seqlist)详解-增删查改
weixin_62357106的博客
01-09 1639
【数据结构】顺序表的实现及增删查改的功能
数据结构之链表：建立、增、删、改、查、排序
qq_60856466的博客
08-23 914
用详细的语言讲述链表的相关操作
基于顺序表的图书管理增删查改
最新发布
03-18
基于顺序表的图书管理系统是一种简单的数据结构，可以实现对图书的增加、删除、查询和修改等操作。下面是对这些操作的介绍： 1. 增加图书：将新的图书信息添加到顺序表的末尾。可以输入图书的名称、作者、出版社等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值