顺序表详解（SeqList）

最新推荐文章于 2024-08-15 14:35:42 发布
最新推荐文章于 2024-08-15 14:35:42 发布
阅读量1.4k 收藏 38
点赞数 48
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SDFsoul/article/details/136197107
版权
本文详细介绍了如何使用C语言实现顺序表，包括顺序表的定义、初始化、插入、删除和查找操作的代码示例，以及如何处理顺序表满时的扩容问题。
摘要由CSDN通过智能技术生成

本文使用C语言进行顺序表的代码实现。

博主将使用代码和相关知识相结合的方式进行讲解，简单易懂，懵懂的大学生一听就会~

顺序表是一种线性表的存储结构，它将数据元素存储在一段连续的存储空间中，每个元素占据一个存储单元，并按照逻辑顺序依次存放。顺序表可以采用数组来实现，通过数组的下标来表示元素在顺序表中的位置，从而实现对元素的快速访问和操作。

一、顺序表的定义

线性表是一种基本的数据结构，它是由一组相同类型的数据元素组成的有序序列。线性表的特点是元素之间的关系是线性的，即每个元素都有一个唯一的索引（也称为位置），并且可以通过索引访问元素。

线性表有两种常见的实现方式：顺序表和链表。顺序表是使用一组连续的内存空间来存储元素，而链表则是使用一组离散的内存空间来存储元素，并通过指针将它们连接起来。

本文讲解顺序表的代码实现。

二、顺序表的实现

我们使用多文件的方法来进行顺序表的实现。

  • SeqList.h用存放需要使用的头文件及声明函数
  • SeqList.c用来实现对于顺序表的操作函数
  • test用来进行顺序表的功能测试和使用

1.顺序表的初始化

//结构体创建
typedef int SQDataType;

typedef struct SeqList
{
	SQDataType* a;
	int size;     // 有效数据的个数
	int capacity; // 容量
}SL;


//顺序表初始化
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

首先创建一个结构体用来存放一个指针a，数据个数和顺序表的容量。

2.设置修改检查函数

//作为每次增添时的检查函数，如果顺序表的存储满了就进行扩容
void SeqListCheckCapacity(SL* ps)
{
	// 满了就要扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

 该函数用于检查顺序表（a）是否大小足够进行添加数据，如果大小为0那么将空间设置为4，如果不够用即用realloc扩容到原大小的二倍。，之后再对相关数值进行修改。

3.从头部插入数据

void SeqListPushFront(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[0] = x;
	ps->size++;

}

头插的方法相当于是将整个顺序表向后挪动一位，最后将第一个位置空下然后插入数据。但是挪动的顺序是从后往前挪动，如果是从前往后的话就会将数据覆盖，从而无法正常插入。

4.从尾部插入数据

void SeqListPushBack(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;

}

尾插就是直接向顺序表最后添加数据。

5.指定位置插入数据

void SeqListInsert(SL* ps, int pos, SQDataType x)
{
	assert(pos <= ps->size);
	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	//将pos位置及之后全部向后移动一位，然后再pos位置上插入x
	ps->a[pos] = x;
	ps->size++;
}

关于assert断言相关知识如果想深入学习可以点击这段话跳转至博主的另一篇博客~

首先使用assert断言进行一个条件判断，确保插入的位置合法。之后的移动数据位置的操作和头插的方法类似，将pos位置和之后的数据全部向后移动一个位置，然后再在pos这个下标的位置上添加数据。

6.从头部删除数据

void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);

	
	int start = 1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];
		++start;
	}
	ps->size--;
}

代码实现的操作就是将第一个位置上的位置进行覆盖，用第一个之后的数据逐一将前面一个的数据进行覆盖，从而达到删除第一个数据的效果。最后将size进行修改。

7.从尾部删除数据

void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);

	ps->size--;
}

直接将顺序表的size进行-1就可以实现删除最后一个数据的操作。

8.指定位置删除数据

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

操作与头删类似，先设置start的数值为要删除的那个下标，然后将start之后的数据依次向前挪动覆盖数据实现在该指定位置的数据删除。

9.指定位置修改数据

void SeqListModity(SL* ps, int pos, SQDataType x)
{
	assert(pos < ps->size);
	ps->a[pos] = x;
}

修改数据的操作十分简单，找到该位置的下标然后进行修改即可完成操作。

10.查找数据

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

	return -1;
}

遍历顺序表，逐个进行对比，与要查找的数据相同时返回该数据位置的下标，未找到返回-1.

三、整体程序代码展现

因为指定位置插入数据的函数和指定位置删除数据的函数可以完成头插尾插，头删尾删的操作，所以在程序中直接使用这两个插入方法进行头尾的操作减少了代码量。

在test.c中通过简单的菜单和分支操作可以对顺序表进行简单的操作。

SeqList.h

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include <stdlib.h>
#include <assert.h>


// 增强程序可维护性
typedef int SQDataType;
// 动态的
typedef struct SeqList
{
	SQDataType* a;
	int size;     // 有效数据的个数
	int capacity; // 容量
}SL;

//typedef struct SeqList SL;

// 增删查改等接口函数
void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void SeqListDestory(SL* ps);

// 头插 尾插 头删 尾删
void SeqListPushBack(SL* ps, SQDataType x);
void SeqListPushFront(SL* ps, SQDataType x);
void SeqListPopBack(SL* ps);
void SeqListPopFront(SL* ps);
void SeqListInsert(SL* ps, int pos, SQDataType x);
void SeqListErase(SL* ps, int pos);

int SeqListFind(SL* ps, SQDataType x);
void SeqListModity(SL* ps, int pos, SQDataType x);

SeqList.c

#include "SeqList.h"

// 增删查改等接口函数

//初始化数组
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

//清除内存
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//作为每次增添时的检查函数，如果顺序表的存储满了就进行扩容
void SeqListCheckCapacity(SL* ps)
{
	// 满了就要扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

// 头插 尾插 头删 尾删
void SeqListPushBack(SL* ps, SQDataType x)
{
	/*SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;*/

	SeqListInsert(ps, ps->size, x);
}

void SeqListPushFront(SL* ps, SQDataType x)
{
	//SeqListCheckCapacity(ps);

	 1、初始条件
	 2、结束条件
	 3、迭代过程
	//int end = ps->size - 1;
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	--end;
	//}

	//ps->a[0] = x;
	//ps->size++;

	SeqListInsert(ps, 0, x);

}

void SeqListPopBack(SL* ps)
{
	//assert(ps->size > 0);

	ps->a[ps->size - 1] = 0;
	//ps->size--;
	SeqListErase(ps, ps->size - 1);
}

void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);

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

void SeqListInsert(SL* ps, int pos, SQDataType x)
{
	assert(pos <= ps->size);
	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	//将pos位置及之后全部向后移动一位，然后再pos位置上插入x
	ps->a[pos] = x;
	ps->size++;
}

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

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

	return -1;
}

//修改pos位置上的值为x
void SeqListModity(SL* ps, int pos, SQDataType x)
{
	assert(pos < ps->size);
	ps->a[pos] = x;
}

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

test.c

#include "SeqList.h"

void TestSeqList1()
{
	SL sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPushBack(&sl, 6);
	SeqListPushBack(&sl, 7);
	SeqListPushBack(&sl, 8);
	SeqListPushBack(&sl, 9);
	SeqListPushBack(&sl, 10);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPushBack(&sl, 11);
	SeqListPrint(&sl);

	SeqListDestory(&sl);
}

void TestSeqList2()
{
	SL sl;
	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);
	SeqListPrint(&sl);

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

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

	SeqListDestory(&sl);
}

void TestSeqList3()
{
	SL sl;
	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);
	SeqListPrint(&sl);
	SeqListInsert(&sl, 1, 20);
	SeqListPrint(&sl);

	SeqListErase(&sl, 1);
	SeqListPrint(&sl);

	SeqListDestory(&sl);
}

void menu()
{
	printf("**********************************************\n");
	printf("1.尾插数据， 2.头插数据\n");
	printf("3.尾删数据， 4.头删数据\n");
	printf("5.打印数据，-1.退出\n");
	printf("**********************************************\n");
	printf("请输入你操作选项:");
}

int main()
{
	SL s;
	SeqListInit(&s);
	int option = 0;
	int x = 0;
	while (option != -1)
	{
		menu();
		scanf("%d", &option);
		switch (option)
		{
		case 1:
			printf("请输入你要插入的数据，以-1结束\n");
			do {
				scanf("%d", &x);
				if (x != -1)
				{
					SeqListPushBack(&s, x);
				}
			} while (x != -1);
			break;
		case 2:
			break;
		case 3:
			break;
		case 4:
			break;
		case 5:
			SeqListPrint(&s);
			break;
		default:
			break;
		}
	}

	SeqListDestory(&s);

	return 0;
}

那么本篇博客到此就结束了，如果可以帮助到你是博主的荣幸！

DevKevin
关注
专栏目录
seqlist
zmjames2000 Just record
02-21 346
#ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct seqlist { int *data; int data_len; //相当于数组下标, 最后一位 int size; //记录顺序表分配的存储容量 }seqlist...
【C语言】详解顺序表(SeqList)
杨同学的博客
07-27 3252
线性表（linearlist）是n个具有相同特性的数据元素的有限序列。顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。可动态增长的数组，要求数据是连续存储的缺陷给小了不够用，给大了可能浪费，非常不实用//定长数组intsize;200。...............
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-01 3681
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。本篇博客我们主要介绍一下顺序表的内容，最后会给出顺序表的应用，也就是之前拖了大家很久的通讯录动态版。
顺序表(SeqList)的理解以及实现
最新发布
Small_entreprene的博客
08-15 1042
SeqList的底层实现（C++），通讯录的实现：模板的好处
SeqList
木子皿--啥都不会的菜鸟
04-02 5364
文章目录1 线性表的顺序存储结构1.1 顺序存储的定义1.2 设计思路1.3 顺序存储结构的元素获取操作1.4 顺序存储结构的元素插入操作1.5 顺序存储结构的元素删除操作2 继承关系图和接口实现 1 线性表的顺序存储结构 1.1 顺序存储的定义 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表中的数据元素。 1.2 设计思路 可以用一维数组实现顺序存储结构。 存储空间：T*...
【数据结构】顺序表(SeqList)（增、删、查、改）详解
Elena's Blog
07-27 3510
在数据结构中，如果要访问或者修改数据结构中的数据不要直接访问，而是应该去调用它的函数来访问和修改，这样会更加规范和安全，也更方便检查出是否出现了越界等错误情况。数组越界是不一定报错的，系统对越界的检查是设岗检查。越界读（读了不属于自己的数据），一般是检查不出来的，往往并不会造成内存奔溃。越界写（缓冲区溢出）如果是修改到标志位才会被检查出来，会造成数据破坏，严重会造成内存奔溃。（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表(SeqList)的基本概念是将元素存储在一个连续的内存空间中，每个元素都有一个唯一的索引，索引从0开始。在C#中，我们可以使用数组来模拟这种数据结构。例如，`SeqList<T>` 类实现了线性表的接口 `IListDS<T>`，...
SeqList.
feng_you000的专栏
06-15 744
基本SeqList:InitSeqList;PrintSeqList; PushBack; PopBack; PushFront;PopFront; Insert; Modified; removedm.
List和SeqList
04-17
不仅自己编写的链表，同时可以调用STL中的list的模板。。是学习链表的基础知识。
seqlist.h头文件
12-27
seqlist.h头文件，包含了其中的源代码。很标准的哦。
Seqlist
狭路相逢勇者胜
06-24 874
#include #include //#include //about bool #define MAXSIZE 100#define ElemType inttypedef struct {  ElemType data[MAXSIZE];  int last; }Seqlist;Seqlist SeqlistInit() {  Seqlist L;  L.last=0;  return
数据结构-顺序表(SeqList)
qq_38684512的博客
10-30 2217
顺序表 SeqListC实现C++实现 结构代表数据和数据之间的关系 1.同属一个集合 不允许元素重复 2.线性关系 一对一的关系 除了第一个之外 没有直接前驱最后一个没有直接后继 中间节点都有唯一前驱和唯一后继 3. 树形关系 一对多的关系 4. 图形关系 多对多的关系 1.逻辑存储 图像的样式 2.物理存储 内存中保存的样式 C实现 1.连续存储的线性聚集（别名 向量） 2.处第一个元素外，...
基于数组实现的顺序表(SeqList)
m0_74343467的博客
05-17 925
顺序表介绍；基于数组实现的顺序表(SeqList)；自我实现顺序表(SeqList)
数据结构--顺序表（SeqList）详解
summer_2022_的博客
07-26 2234
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序储存是指用一组地址连续的储存单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序储存结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
数据结构——顺序表（SeqList）
XLZ_44847的博客
11-03 604
顺序表，顾名思义就是顺序储存数据的数据管理方式。在物理层面来看，顺序表将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。因为顺序表采用的是一段物理地址连续的储存单元一次存储数据元素，所以我们一般会采用数组的方式来存储。涉及到数组的存储，我们便会有两种方式，一种是静态的顺序表，即使用定长的数组来存储元素；而我们今天介绍的是另一种动态的顺序表，即采用动态开辟的数组进行数据的存储。
c_SeqList
_tree_
05-03 902
//顺序表，栈上分配静态*****//凡是有关设计_size的数据都需要一个辅助变量来帮忙,保证数据安全 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <assert.h> #define MAX_SIZE 10typedef int DAtatType; typedef struct SeqList {
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

DevKevin

你们的点赞收藏是对我最大的鼓励

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

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

打赏作者

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

抵扣说明：

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

余额充值