【DS】顺序表@线性表 —— 增删查改

已于 2022-06-24 19:57:26 修改
阅读量1.4k 收藏 9
点赞数 18
分类专栏： 初阶数据结构
于 2022-01-04 15:11:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54851255/article/details/122303075
版权

数据结构 链表

文章目录

0. 线性表概念

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

  • 线性表在逻辑上是线性结构，也就说是连续的一条直线。

  • 但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组（顺序表）和链式结构（链表）的形式存储。

1. 顺序表概念及结构

🔑顺序表就是数组，在数组的基础上要求从头开始，要求数据挨着挨着连续存储，没有跳跃间隔。

顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储元素。
#define N 1000
typedef int SLDataType;

//静态顺序表
typedef struct SeqList
{
	SLDataType data[N];
	int size;//表示数组中存储多少个数据
}SL;

静态顺序表的缺点：

❄️1. 如果满了，就无法再插入。
❄️2. 数组大小给多少合适？这个很难确定，N给小了不够用，N给大了浪费。

因此现实中我们基本都是使用动态顺序表，动态分配内存空间，所以下面我们实现动态顺序表。

  1. 动态顺序表：使用动态开辟的数组存储。
typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;
	int size;//表示数组中存储多少个有效数据
	int capacity;//数组实际能存数据的容量
}SL;

2. 顺序表的增删查改

函数接口 —— 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;

//接口函数--命名风格跟着STL走，方便后续学习STL
void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void SeqListCeckCapacity(SL* ps);
void SeqListDestroy(SL* ps);
//尾插
void SeqListPushBack(SL* ps, SLDataType x);
//尾删
void SeqListPopBack(SL* ps);
//头插
void SeqListPushFront(SL* ps, SLDataType x);
//头删
void SeqListPopFront(SL* ps);
//指定位置插入
void SeqListInsert(SL* ps,int pos,SLDataType x);
//删除指定位置数据
void SeqListErase(SL* ps,int pos);
//查找
int SeqListFind(SL* ps, SLDataType x);
//若找到--则返回下标
//找不到--返回-1
int SeqListFind(SL* ps, SLDataType x);

2.0 初始化、销毁、打印基本接口

2.0.1 初始化

初始化很有必要。开始时，顺序表中什么数据也没有，甚至也还没有为它动态申请一段空间。

因此，ps->a要置NULL，标识它是野指针。ps->size和ps->capacity都要置0，否则就是随机值了。

void SeqListInit(SL* ps)
{
    assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

注意：为什么传的是这个顺序表的地址？这是因为函数传参，形参是实参的拷贝，形参的改变不会影响实参。

2.0.2 打印

我们要写一点，就打印出来验证一下正确性，就写一个打印函数，遍历即可很简单。

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

2.0.3 销毁

现在我们写的是动态顺序表，那么malloc/realloc动态申请的空间，要记得释放，否则会发生内存泄漏。

关于此，可以复习一下这篇文章 动态内存函数，我顺便也复习了一下，发现有些东西用惯了之后，对于它们是怎么来的会有点淡忘。

void SeqListDestroy(SL* ps)
{
    assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

2.1 尾插尾删

2.1.1 扩容接口

🔑但凡插入数据就要考虑，空间够不够用是否需要增容的问题

void SeqListCeckCapacity(SL* ps)
{
    assert(ps);
	if (ps->size == ps->capacity)
	{
        //1.没有空间 —— 申请空间
        //2.空间不够 —— 扩容
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

这里可能唯一要注意一下的，就是realloc函数，文档中如是写——

在这里插入图片描述

因此我们把 第一次申请空间 与 后期的调整空间 完美融合写在一起了，同时处理了没有空间和空间不够两种情况。

2.1.2 尾插

void SeqListPushBack(SL* ps, SLDataType x)
{
    assert(ps);
	SeqListCheckCapacity(ps);
	ps->a[ps ->size] = x;
	ps->size++;
}

2.1.3 尾删

🔑 删除数据就要考虑是不是删空了，没的删了，却还在调用这个函数，那就不对了

推荐直接断言暴力终止掉程序，毕竟，就是你用错了。

在这里插入图片描述

void SeqListPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);//断言暴力终止掉程序。若出现删多了的情况，就蹦出窗口终止程序
	ps->size--;
}

断言效果 ——
在这里插入图片描述

2.2 头插头删

2.2.1 头插

  • 插入数据依然要考虑扩容问题
  • 无论是头插还是头删，为了保证顺序表从开始位置连续，都需要挪动数据 —— 想好是从尾 还是 从头 开始挪动，保证数据不会被覆盖丢失。
  • 画好图，时刻注意边界

在这里插入图片描述

void SeqListPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

2.2.2 头删

  • 删除数据依然要考虑删空时，越界访问的情况
  • 画图注意边界

void SeqListPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

2.3 指定位置插入、删除指定位置数据、查找

查找常和指定位置插入、指定位置删除搭配使用。

2.3.1 查找

//查找--找到了则返回x位置下标，没有找到则返回-1
int SeqListFind(SL* ps, SLDataType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

2.3.2 指定位置插入

与头插完全类似

void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

2.3.3 删除指定位置数据

与头删完全类似

void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	int start = pos + 1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];
		start++;
	}
	ps->size--;
}

2.3.4 复用

有了指定位置插入和指定位置删除，就可以复用这些接口，完成头插头删尾插尾删 ——

//尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	SeqListInsert(ps, ps->size, x);
}

//尾删
void SeqListPopBack(SL* ps)
{
	SeqListErase(ps, ps->size - 1);
} 

//头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListInsert(ps, 0, x);
}   

//头删
void SeqListPopFront(SL* ps)
{
	SeqListErase(ps, 0);
}

分分钟搞定。

3. 顺序表的问题及思考

  • 顺序表优点 ——

    支持随机访问，方便做查找。

  • 顺序表缺陷 ——

  1. 空间不够需要增容，增容是要付出代价的。
  2. 为了避免频繁扩容，我们基本都是按倍数去扩（扩2倍），可能会造成一定的空间浪费。
  3. 顺序表要求数据从开始位置保持连续，那么中间和头部的插入，就需要挪动数据，时间复杂度为O(N)，效率不高。

针对顺序表的缺陷，引出了下一节 —— 链表

未完待续@边通书

附：源代码

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;


//接口函数--命名风格跟着STL走，方便后续学习STL
void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void SeqListDestroy(SL* ps);
void SeqListCheckCapacity(SL* ps);
//尾插
void SeqListPushBack(SL* ps, SLDataType x);
//尾删
void SeqListPopBack(SL* ps);
//头插
void SeqListPushFront(SL* ps, SLDataType x);
//头删
void SeqListPopFront(SL* ps);
//指定位置插入
void SeqListInsert(SL* ps, int pos, SLDataType x);
//删除指定位置的数据
void SeqListErase(SL* ps, int pos);

//查找--找到了则返回x位置下标，没有找到则返回-1
int SeqListFind(SL* ps, SLDataType x);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

void SeqListInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

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

void SeqListDestroy(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
}

void SeqListCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a,sizeof(SLDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

void SeqListPushBack(SL* ps, SLDataType x)
{
	SeqListInsert(ps, ps->size, x);
	//assert(ps);
	//SeqListCheckCapacity(ps);
	//ps->a[ps->size] = x;
	//ps->size++;
}

void SeqListPopBack(SL* ps)
{
	SeqListErase(ps, ps->size - 1);
	//assert(ps);
	//assert(ps->size);
	//ps->size--;
}

void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListInsert(ps, 0, x);
	/*assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;*/
}

void SeqListPopFront(SL* ps)
{
	SeqListErase(ps, 0);
	//assert(ps);
	//assert(ps->size);
	//int start = 1;
	//while (start < ps->size)
	//{
	//	ps->a[start - 1] = ps->a[start];
	//	start++;
	//}
	//ps->size--;
}

void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	int start = pos + 1;
	while (start < ps->size )
	{
		ps->a[start - 1] = ps->a[start];
		start++;
	}
	ps->size--;
}

int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;
}

test.c

关于测试文件，就是随写随测，把每种情况都测到，这里主要是增容呀，删空时的越界访问呀，还有就是基本的逻辑，把我自己的贴出来

#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

//测试尾插尾删
void TestSeqList1()
{
	SL sl;
	SeqListInit(&sl);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);

	SeqListPrint(&sl);

	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	//SeqListPopBack(&sl);
	//SeqListPopBack(&sl);

	SeqListPrint(&sl);
	SeqListDestroy(&sl);
}

//测试头插头删
void TestSeqList2()
{
	SL sl;
	SeqListInit(&sl);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);

	SeqListPushFront(&sl, 0);
	SeqListPushFront(&sl, -1);
	SeqListPushFront(&sl, -2);
	SeqListPrint(&sl);

	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);

	printf("%d\n", SeqListFind(&sl,3));

	SeqListDestroy(&sl);
}

//测试指定位置的插入删除
void TestSeqList3()
{
	SL sl;
	SeqListInit(&sl);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);

	SeqListInsert(&sl, 2, 30);
	SeqListInsert(&sl, 0, 0);
	SeqListInsert(&sl, sl.size, 80);

	SeqListPrint(&sl);
	
	//配合使用
	int pos = SeqListFind(&sl, 4);
	if (pos != -1)
	{
		SeqListInsert(&sl, pos, 40);
	}

	SeqListPrint(&sl);

	SeqListDestroy(&sl);

}

//复用SeqListInsert测试头插尾插
void TestSeqList4()
{
	SL sl;
	SeqListInit(&sl);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);

	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPrint(&sl);

	SeqListPopFront(&sl);
	SeqListPopFront(&sl);

	SeqListPopBack(&sl);
	SeqListPopBack(&sl);

	SeqListPrint(&sl);

	//假如我要删3
	int pos = SeqListFind(&sl, 3);
	if (pos != -1)
	{
		SeqListErase(&sl, pos);
	}
	SeqListPrint(&sl);

	SeqListDestroy(&sl);
}
int main()
{
	//TestSeqList1();
	//TestSeqList2();
	//TestSeqList3();
	TestSeqList4();

	return 0;
}
浮光 掠影
关注
专栏目录
线性表中顺序表的增删改查
06-21
顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查
顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法.zip
08-16
在本压缩包中，我们重点关注了三种类型的线性表：顺序表、链表和双链表，以及它们的增删查改操作和链表逆置等常见算法。 顺序表是一种最简单的线性表实现，它在内存中是连续存储的，可以通过数组来表示。对于顺序表...
线性表的增删改查
qq_43794560的博客
09-01 187
【代码】线性表的增删改查。
线性表的插入、删除、查找（顺序存储）（附有完整代码）
最新发布
2401_84024302的博客
07-22 666
一个数据结构的基本操作是指其最核心、最基本的操作。其他较复杂的操作可通过调用其基本操作来实现。线性表的主要操作如下。● InitList(&L):初始化表。构造一个空的线性表。· Length(L):求表长。返回线性表L的长度，即L中数据元素的个数。● LocateElem(L,e):按值查找操作。在表I中查找具有给定关键字值的元素。·GetElem(L,i):按位查找操作。获取表工中第i个位置的元素的值。· ListInsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e。
线性表的完善增删改查
Coder的博客
12-14 461
#include #include #include #define OK 1 #define ERROR 0 typedef int Status; typedef int ElementType; typedef struct {     ElementType *data;     int length; }Sqlist; int MAXSIZE = 20;
线性表——顺序表的增删改查
weixin_46398446的博客
01-03 2156
目录一、顺序表的特点二、顺序表的特点三、代码实现结构体1.增（插入）2.删（删除）3.改（修改）4.查（查找）完整代码注意 一、顺序表的特点 逻辑上相邻的两个元素在物理位置上也相邻。 二、顺序表的特点 优点 1.可随机存取，根据表头元素地址和元素序号表示表中任意一个元素。简单来说可以用公式到达任意元素。 2.存储密度高，每个结点只存储数据元素。 缺点 1.插入和删除操作需要移动大量元素。 2.线性表变化较大时，难以确定存储空间的容量。 3.村年初分配需要一整段连续的存储空间，不够灵活。 三、代码
php线性表顺序存储实现代码(增删查改)
10-28
PHP线性表顺序存储实现代码（增删查改） PHP实现线性表顺序存储的代码，需要的朋友可以参考下。线性表是一种基本的数据结构，它可以用来存储和操作一组数据。顺序存储是指将数据存储在一块连续的内存空间中，每个...
数据结构 c语言 线性表 增删查改保存.txt
07-24
数据结构 c语言 线性表 增删查改保存 InitList(Linklist &L,int &k); PrintList(Linklist &L,int &k); ListInsert(Linklist &L,int &k); ListDelete(Linklist &L,int &k); void ListSave(Linklist &L); void cd();
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
文档中包含顺序表和单链表的增、删、改、查等基本操作，并且通过实际案例来展示这些操作的应用场景。 #### 二、顺序表 **定义**：顺序表是一种线性表的存储结构，它使用一段地址连续的存储单元依次存储线性表中的...
线性表的顺序存储 增删改查功能
03-16
线性表的顺序存储 增删改查功能 dos窗口输入输出
线性表1：顺序表的增 删 改 查
hellohelloe的博客
01-28 592
顺序存储结构【顺序表】的增 删 改 查seqlist线性表新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 此系列文主要用于自查、复习。所以行文、逻辑、思路是按照个人的思考方式来的，但也希冀能帮到一二三位初学者。 线性表 你
线性表seqlist——增删查改
mmm174的博客
04-25 398
线性表增删查改，详！！！
数据结构——线性表（单链表的增、删、查）
Duanqi1的博客
07-06 544
---------单链表--------- 逻辑上相邻的数据元素物理存储上不一定相邻，即数据元素离散的分布在存储空间中。元素之间的顺序关系通过指针链接。增删操作只用修改指针即可，不用每次都移动大量的数据元素。 使用链式存储，内存空间利用率大，存储密度低，但每次查找元素都需要从表头开始遍历，失去了随机存取的优点。 ★注：为了操作上的方便，通常在链表第一个结点前附加一个头结点，结点内通常不存储任何信息。 ...
一个增删改查插的线性表（一）
HanMamnHanah的博客
03-27 467
    又是美好的一天结束了，为了让被催作业的每一天过得不是那么痛苦，睡觉之前上传一下最近写的一个拥有初始化、增删改查、指定位置读取、修改，插入元素，读取指定位置下标的一个链表代码seqlist.h#pragma once #include&lt;stddef.h&gt; #define SeqlistMaxSize 1000 typedef char SeqType; typedef st...
java实现线性表的增删改查
weixin_50901244的博客
11-27 1409
java实现线性表的增删改查1线性表的增加1.1 线性表的尾部插入指定元素value1.2 线性表的头部插入指定元素value1.3 线性表中间位置插入指定元素value 1线性表的增加 线性表增加的时候，一定要先判断数组是否已满，如果数组已满，要先扩容 1.1 线性表的尾部插入指定元素value public void addLast(int value){ // 先判断当前数组是否已满 if (size==data.length){ // 如果满了
数据结构线性表的基本操作（增删改查）
qq_45562742的博客
05-13 575
#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+.
线性表实现增删改查等基本操作
DRZ_2000的博客
02-03 2410
线性表实现 增删改查 等基本操作 当数据结构是线性结构时，我们可以用顺序表或者是链表实现，此处我们先讨论顺序表的一些基本操作 首先为了便于程序的演示以及说明，我们先定义相应的数据结构如下： typedef struct Vector { int size, length; //顺序表的总体大小以及现有长度 int *data; //data指向存储数据数组的首地址...
C语言实现链式线性表及其增删查改操作
"本资源介绍了线性表的链式存储方式实现，包括创建、显示和操作功能。" 线性表是一种基础的数据结构，它由一系列元素（数据项）组成，这些元素在内存中通过链接的方式进行存储和管理。在这里，我们看到的是一个...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浮光 掠影

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

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

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

打赏作者

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

抵扣说明：

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

余额充值