数据结构之顺序表详解

已于 2023-05-28 22:14:06 修改
阅读量256 收藏 1
点赞数 4
分类专栏： 初级数据结构 文章标签： 数据结构 c语言
于 2023-03-11 15:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68624665/article/details/129462353
版权

目录

前言

1.顺序表

2. 顺序表及其功能实现

2.1 准备工作

2.2 顺序表结构的创建

2.3 顺序表的初始化

2.4 顺序表向后插入数据

2.5 打印函数的实现

 2.5 顺序表从后删除数据

2.6  顺序表向前插入数据

 2.7 顺序表从前删除数据

 2.8 查找功能实现

2.9  顺序表在pos位置插入

 2.10  顺序表在pos位置删除

 总代码：

前言

今天给大家带来的是数据结构的顺序表结构，以及与其的有关功能的实现，在数据结构的这部分内容，可能有些知识点有点难以理解，在需要时小编会配合图画，让大家能够更好的理解，那么下面就让我们直接步入正题吧。

1.顺序表

   顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
 储。在数组上完成数据的增删查改。
此外顺序表分两种类型：
静态顺序表(数组大小是规定的不易于使用) 

 动态顺序表（按需申请）

2. 顺序表及其功能实现

2.1 准备工作

在实现顺序表时，我们首先需要创建3个文件

text.c ——测试文件，对实现功能的测试

Sqlist.c ——在此处实现增删查改等功能

Sqlist.h—— 对函数进行声明

2.2 顺序表结构的创建

#define INIT_CAPACITY 4
typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

这里我们采用动态顺序表，这里我们利用宏定义，定义一个初始化的容量，以便于顺序表初始化的操作。

2.3 顺序表的初始化

void SeqListInit(SeqList* ps)
{
	assert(ps);//对ps指针进行断言，如果该是空指针结束程序，否则什么都不发生
	ps->size = 0;
	ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = INIT_CAPACITY;
}

初始化具体的操作是，首先将有效数据个数置为0（因为此时还无数据存储），然后就是利用malloc函数申请一块初始空间，如果申请失败，用perror函数输出失败信息，然后结束函数，最后将容量赋值初始大小。

2.4 顺序表向后插入数据

void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* temp = (SLDateType)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
	ps->a[ps->size++] = x;
}

在插入数据之前，首先我们要对空间进行判断，如果空间已满，我们则需要使用realloc函数（如果对这该函数不了解，大家可以观看小编的动态内存管理一文）对该进行增容，这里我们扩大的容量是之前的两倍，大家也可以自己更改，同理增容失败的话，返回错误信息，终止程序，最后就是对该容量进行赋值到现在的值，有效数据个数+1，在前成员后添加需要添加的成员。

2.5 打印函数的实现

这里我们怎么看上面的我们实现的后插入法的是否正确呢？最直观的办法就是实现一个打印函数，方便我们具体查看。

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

打印函数实现原理比较简单，这里我们就不加以讲解，我们这里主要目的是测试后插入法的正确性，那么接下来我就对其进行测试运行一下。

void text()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s,1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
}

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

这里我们依次向后插入1~4的数据，打印的结果如下:

 2.5 顺序表从后删除数据

既然有插入那么就会有删除，这里我们就对删除函数进行实现一下

void SeqListPopBack(SeqList* ps)
{  
	assert(ps);
	assert(ps->size > 0);//对有效值个数进行判断，小于0，就退出函数
	ps->size--;
}

对于删除函数这里的操作是比较简单的，在删除前我们需要对有效值个数进行判断，个数为0，是不能删除的，那么我们就理应退出程序，否则就对有效数值减1。

这里我们对该进行测试一下：

void text()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s,1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);
}

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

结果如下：

2.6  顺序表向前插入数据

实现了后插法这里我们实现前插法。

void SeqListPushFront(SeqList* ps, SLDateType x)
{    
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* temp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
	int i = 0;
	for (i = ps->size; i >=0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}

和后插法一样进行插入时我们先进行对容量进行判断，是否进行扩容操作，由于是进行前插法，这里我们需要将之前的有效数据向后移动，移动后，对首元素赋值应该插入的值，对有效值的个数进行+1操作。

由于每次我们插入前都需要判断是否进行增容操作那么我们就可以将该部分代码进行函数封装，如下

void SLCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* temp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
}

那么对于前插和后插法，我们可以简写为：

后插：

void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;
}

前插：

void SeqListPushFront(SeqList* ps, SLDateType x)
{    
	assert(ps);
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i >=0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}

然后这里我们对前插法进行测试

void text2()
{   
	SeqList s;
	SeqListInit(&s);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPushFront(&s, 4);
	SeqListPrint(&s);
}

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

结果如下：

 2.7 顺序表从前删除数据

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

删除第一个首元素，实际上就是把第一个元素后面的元素一次从前覆盖，然后对有效数据个数-1，即可

运行测试：

void text2()
{   
	SeqList s;
	SeqListInit(&s);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPushFront(&s, 4);
	SeqListPrint(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);
}

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

结果如下:

 2.8 查找功能实现

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

这里我们是以内容查找，对有效的数据进行循环，找到内容一致的元素就返回该下标，否则返回-1。

运行测试：

void text3()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SLDateType x = 0;
	printf("输入你要查找的内容>");
	scanf("%d", &x);
	int i = SeqListFind(&s, x);
	printf("你所查找的元素在：%d", i);
}
int main()
{
	text3();
	return 0;
}

结果如下：

2.9  顺序表在pos位置插入

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <ps->size);
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i >=pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[pos] = x;
	ps->size++;
}

对于pos的大小范围要求是0~ps->size，既然要在pos位置插入那么我们就行需要将pos之后的有效元素后移，然后再给pos位置赋值要插入的内容。

运行测试：

void text4()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListInsert(&s, 1, 5);
	SeqListInsert(&s, 2, 6);
	SeqListPrint(&s);

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

结果如下：

 2.10  顺序表在pos位置删除

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	int i = 0;
	for (i = pos+1; i < ps->size; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
}

 这里和上面头删除的原理相同，只是这里是将pos位置之后的值进行覆盖。

运行测试：

void text4()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListInsert(&s, 1, 5);
	SeqListInsert(&s, 2, 6);
	SeqListPrint(&s);
	SeqListErase(&s, 2);
	SeqListErase(&s, 3);
	SeqListPrint(&s);
}
int main()
{
	text4();
	return 0;
}

结果如下：

 总代码：

 text.c

#include"Sqlist.h"
void text1()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s,1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);
}
void text2()
{   
	SeqList s;
	SeqListInit(&s);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPushFront(&s, 4);
	SeqListPrint(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);
}
void text3()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SLDateType x = 0;
	printf("输入你要查找的内容>");
	scanf("%d", &x);
	int i = SeqListFind(&s, x);
	printf("你所查找的元素在：%d", i);
}
void text4()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListInsert(&s, 1, 5);
	SeqListInsert(&s, 2, 6);
	SeqListPrint(&s);
	SeqListErase(&s, 2);
	SeqListErase(&s, 3);
	SeqListPrint(&s);
}
int main()
{
	text4();
	return 0;
}

Sqlist.c

#include<stdio.h>
#include"Sqlist.h"

void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->size = 0;
	ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = INIT_CAPACITY;
}
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
void SLCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* temp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
}
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;
}
void SeqListPopBack(SeqList* ps)
{  
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}
void SeqListPushFront(SeqList* ps, SLDateType x)
{    
	assert(ps);
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i >=0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
int SeqListFind(SeqList* ps, SLDateType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <ps->size);
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i >=pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	int i = 0;
	for (i = pos+1; i < ps->size; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
}

Sqlist.h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define INIT_CAPACITY 4

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);
// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

半只牛马
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#数据结构之顺序表(SeqList)实例详解
09-03
主要介绍了C#数据结构之顺序表(SeqList)实现方法,结合实例形式较为详细的分析了顺序表的定义、原理与具体实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
详解（数据结构C语言版）顺序表
最新发布
10-02
顺序表演示程序
头歌数据结构顺序表的基本操作1-6关
05-18
头歌数据结构顺序表的基本操作1-6关 第1关：顺序表的插入操作 第2关：顺序表的删除操作 第3关：顺序表的按照序号查找值操作 第4关：顺序表的按照值查找序号操作 第5关：顺序表的逆置操作 第6关：两个有序顺序表的合并操作 稳过
【数据结构】顺序表详解
胡坚涛的博客
11-11 1520
数据结构之顺序表详解
【数据结构】详解顺序表
weixin_60371270的博客
10-05 2561
本文主要讲述了线性表之顺序表的概念和分类以及接口实现。
顺序表（数据结构）
outdated_socks的博客
04-07 5151
顺序表详解
数据结构 —— 顺序表的结构、功能（增删查改）。
wihkum
07-08 508
数据结构 —— 顺序表
C语言数据结构 链表与归并排序实例详解
12-31
C语言数据结构 链表与归并排序实例详解 归并排序适合于对链表进行原址排序，即只改变指针的连接方式，不交换链表结点的内容。 归并排序的基本思想是分治法：先把一个链表分割成只有一个节点的链表，然后按照一定顺序...
JavaScript数据结构之广义表的定义与表示方法详解
12-11
本文实例讲述了JavaScript数据结构之广义表的定义与表示方法。分享给大家供大家参考，具体如下： 广义表是线性表的推广，也有人称其为列表。 那么它和线性表有什么区别呢？线性表中每个成员只能是单个元素，而广义表...
【数据结构】手把手带你搞懂顺序表(带图详解）
Z1tai的博客
02-04 1257
在本篇博客中，我会概述顺序表、讲解链表的概念和结构分类、以及使用C语言实现单链表。话不多说，我们这就开始。
数据结构-基础算法系列——顺序表
yaoguaiba579567的博客
10-09 114
  数据结构中的顺序表非常的简单，其实就是我们平常使用的数组，对，编程语言里面应该都有，但是只是学习编程（除了C语言这类），并无法知道其实它另有玄机：它在计算机主存里是一块连续的地址，其实主要是链式存储和顺序存储的区别，一图以蔽之： 首先说明一下，上面是简单的一个例子，并不涉及操作系统中内存管理的内容，只是简单表达一下，顺序存储和链式存储的区别。（这两种存储结构很重要，很多数据结构都会涉及。） 上面举了一个以整数为元素的数组的例子，顺序存储的列表就是数组，链式存储的列表就是链表。可以看
数据结构--知识点3--顺序表
ANingL的博客
08-30 682
文章目录一、概念 一、概念
【数据结构】顺序表和链表重点知识汇总（附有代码）
qq_68993495的博客
09-22 814
Java实现数据结构之顺序表和链表，很想对你有帮助，共同进步~！
数据结构---顺序表(重点)
mzc的博客
05-21 311
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 1.静态顺序表：使用定长数组存储。 2.动态顺序表：使用动态开辟的数组存储 // 顺序表的静态存储 #define N 100 typedef int SLDataType; typedef struct SeqList { SLDataType ar...
数据结构：线性表之顺序表总结
weixin_44025784的博客
04-29 448
对数据结构顺序表的总结
数据结构初阶——顺序表
热门推荐
m0_64607843的博客
04-29 1万+
博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构！！！
算法2.1-算法2.12顺序表和链表模拟
m0_65185254的博客
10-07 4704
数据结构作业
数据结构第二课 | 顺序表（详解）
m0_61933976的博客
04-12 1220
数据结构第二课（1）-----------------线性表之===》顺序表（详解）
数据结构与算法 顺序表、链表总结
m0_58381606的博客
03-08 492
链表是一种随机存储在内存中的节点对象集合。节点包含两个字段，即存储在该地址的数据和包含下一个节点地址的指针。链表的最后一个节点包含指向null的指针。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VhHZYb70-1678256000199)(image/2021-03-12-21-00-33.png)]
数据结构线性结构详解
08-22
- *2* [详解Redis数据结构之跳跃表](https://download.csdn.net/download/weixin_38617604/14831886)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

半只牛马

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

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

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

打赏作者

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

抵扣说明：

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

余额充值