顺序表（Ｃ语言版）

已于 2024-04-15 20:24:10 修改
阅读量996 收藏 20
点赞数 28
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2024-04-15 20:21:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79772464/article/details/137749970
版权
本文详细介绍了顺序表的基本概念、分类（静态和动态）、C语言中的动态顺序表实现，包括初始化、插入（尾插、头插）、删除、查找、指定位置操作以及销毁顺序表。最后展示了如何基于顺序表实现通讯录功能。
摘要由CSDN通过智能技术生成

 

前言：本篇文章我们来详细的讲解一下顺序的有关知识，这篇文章中博主会以C语言的方式实现顺序表。以及用顺序表去实现通讯录的代码操作。

目录

一.顺序表的概念

二.顺序表的分类

1.静态顺序表

三.动态顺序表的实现 

1.顺序表的初始化

2.顺序表的尾插 

3.顺序表的尾删

4.顺序表的头插 

5.顺序表的头删

6.打印顺行表

7.查找表内元素

​编辑 8.指定位置插入

9.指定位置删除 

10.销毁顺序表

四.顺序表所有实现代码 

五.结言

一.顺序表的概念

在学习顺序表之前我们要了解顺序表的概念：

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

笼统的说就是顺序表是一种存储结构，也就是我们所说的数据结构。

那么什么是数据结构呢？

其实我们最早接触到的数据结构就是数组，一种在连续的空间内存储数据的结构。

简单来说存储数据的结构就是数据结构，在日常生活中我们避免不了的要对数据进行增删查改，那么这就要基于我们的数据结构来实现了。

二.顺序表的分类

1.静态顺序表

所谓的静态顺序表就是：使用定长数组存储元素。

也就是使用一个固定的空间来存放。

2.动态顺序表 

所谓的静态顺序表就是：使用动态开辟的数组存储。

在后续的操作中如果空间不够则会扩容。

三.动态顺序表的实现 

动态顺序表就是基于静态顺序表的改造升级款，所以我们只对动态顺序表进行讲解，下面会有代码以及详细的讲解。

1.顺序表的初始化

首先我们需要做好对于我们顺序表的准备工作，以防随机值以及其他意外情况的发生：

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

首先防止的就是向我们的函数传递一个空指针，所以在这里断言一下。

并把我们顺序表的内容进行初始化。、

2.顺序表的尾插 

void SLbackpush(SL* sl, SLType x)
{
	assert(sl);
	if (sl->capacity == sl->size)
	{
		int newcapacity = sl->capacity == 0 ? 4 : 2 * sl->capacity;
		SLType* temp = (SLType*)realloc(sl->a,sizeof(SLType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc error!");
			return;
		}
		sl->capacity = newcapacity;
		sl->a = temp;
	}
	sl->a[sl->size] = x;
	sl->size++;
}

在进行插入的同时我们需要进行对空间的判断判断是否还有空间，之后再进行插入。由于我们后续还要进行我们的头插，以及指定位置插入所以我们可以将判断是否还有空间包装成一个函数，方便后续的使用。

void IfCapacity(SL* sl)
{
	assert(sl);
	if (sl->capacity == sl->size)
	{
		int newcapacity = sl->capacity == 0 ? 4 : 2 * sl->capacity;
		SLType* temp = (SLType*)realloc(sl->a, sizeof(SLType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc error!");
			return;
		}
		sl->capacity = newcapacity;
		sl->a = temp;
	}
}
void SLbackpush(SL* sl, SLType x)
{
	assert(sl);
	IfCapacity(sl);
	sl->a[sl->size] = x;
	sl->size++;
}

就像这样。 

3.顺序表的尾删

void SLbackpop(SL* sl)
{
	assert(sl);
	sl->size--;
}

这个就简单很多了，就是将 size-- 这样当插入下一个数据的时候就会将要删除的数据覆盖，以达到尾删的目的。

4.顺序表的头插 

void SLheadpush(SL* sl, SLType x)
{
	assert(sl);
	IfCapacity(sl);
	for (int i = sl->size; i >0; i--)
	{
		sl->a[i] = sl->a[i - 1];
	}
	sl->a[0] = x;
	sl->size++;
}

与尾删不一样的就是需要将原有的数据像后挪动一格，之后再进行头插也没有什么可以说的。

5.顺序表的头删

void SLhedpop(SL* sl)
{
	assert(sl);
	for (int i = 0; i < sl->size-1; i++)
	{
		sl->a[i] = sl->a[i + 1];
	}
	sl->size--;
}

 时我们也只是需要将后面的数据向前挪动一格将第一个数据覆盖即可。

6.打印顺行表

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

这个就是很简单的打印函数了没有什么好讲的。

7.查找表内元素

int SLfind(SL* sl,SLType x)
{
	assert(sl);
	int i = 0;
	while (sl->a[i]!=x&&i<sl->size)
	{
		i++;
	}
	if (i == sl->size)
	{
		return 0;
	}
	return i;
}

同样这也没有什么好说的遍历顺序表当遇到寻找元素时退出循环，返回元素所在的位置。没有找到则返回0。 

 8.指定位置插入

void Slrandompush(SL* sl, int flag, SLType x)
{
	assert(sl);
	assert(flag < sl->size);
	IfCapacity(sl);
	for (int i = sl->size; i >= flag; i--)
	{
		sl->a[i] = sl->a[i - 1];
	}
	sl->a[flag] = x;
	sl->size++;
}

9.指定位置删除 

void SLrandompop(SL* sl, int flag)
{
	assert(sl);
	assert(flag < sl->size);
	for (int i = flag; i < sl->size-1; i++)
	{
		sl->a[i] = sl->a[i + 1];
	}
	sl->size--;
}

10.销毁顺序表

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

以防空间的浪费要将使用完的空间free掉。 

四.顺序表所有实现代码 

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

#define CP 20
//typedef int SLType;

//typedef strcuct SL
//{
//	SLType* a[CP];
//	int size;
//}SL;
typedef int SLType;

typedef struct SL
{
	SLType* a;
	int size;
	int capacity;
}SL;

void SLinit(SL* sl);
void SLbackpush(SL* sl, SLType x);
void SLbackpop(SL* sl);
void SLheadpush(SL* sl, SLType x);
void SLhedpop(SL* sl);
void SLprint(SL* sl);
int SLfind(SL* sl,SLType);
void Slrandompush(SL* sl, int flag,SLType x);
void SLrandompop(SL* sl, int flag);
void SLdestory(SL* sl);


SL.c
#include"SL.h"

void SLinit(SL* sl)
{
	assert(sl);
	sl->a = NULL;
	sl->capacity = sl->size = 0;
}
void IfCapacity(SL* sl)
{
	assert(sl);
	if (sl->capacity == sl->size)
	{
		int newcapacity = sl->capacity == 0 ? 4 : 2 * sl->capacity;
		SLType* temp = (SLType*)realloc(sl->a, sizeof(SLType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc error!");
			return;
		}
		sl->capacity = newcapacity;
		sl->a = temp;
	}
}
void SLbackpush(SL* sl, SLType x)
{
	assert(sl);
	IfCapacity(sl);
	sl->a[sl->size] = x;
	sl->size++;
}
void SLbackpop(SL* sl)
{
	assert(sl);
	sl->size--;
}
void SLheadpush(SL* sl, SLType x)
{
	assert(sl);
	IfCapacity(sl);
	for (int i = sl->size; i >0; i--)
	{
		sl->a[i] = sl->a[i - 1];
	}
	sl->a[0] = x;
	sl->size++;
}
void SLhedpop(SL* sl)
{
	assert(sl);
	for (int i = 0; i < sl->size-1; i++)
	{
		sl->a[i] = sl->a[i + 1];
	}
	sl->size--;
}
void SLprint(SL* sl)
{
	assert(sl);
	for (int i = 0; i < sl->size; i++)
	{
		printf("%d->", sl->a[i]);
	}
	printf("\n");
}
int SLfind(SL* sl,SLType x)
{
	assert(sl);
	int i = 0;
	while (sl->a[i]!=x&&i<sl->size)
	{
		i++;
	}
	if (i == sl->size)
	{
		return 0;
	}
	return i;
}
void Slrandompush(SL* sl, int flag, SLType x)
{
	assert(sl);
	assert(flag < sl->size);
	IfCapacity(sl);
	for (int i = sl->size; i >= flag; i--)
	{
		sl->a[i] = sl->a[i - 1];
	}
	sl->a[flag] = x;
	sl->size++;
}
void SLrandompop(SL* sl, int flag)
{
	assert(sl);
	assert(flag < sl->size);
	for (int i = flag; i < sl->size-1; i++)
	{
		sl->a[i] = sl->a[i + 1];
	}
	sl->size--;
}
void SLdestory(SL* sl)
{
	assert(sl);
	free(sl->a);
	sl->a = NULL;
	sl->capacity = 0;
	sl->size = 0;
}

test.c

#include "SL.h"

void Test()
{
	SL sl = { 0 };
	SLbackpush(&sl, 1);
	SLheadpush(&sl, 0);
	SLbackpush(&sl, 2);
	SLbackpush(&sl, 3);
	SLbackpush(&sl, 4);
	SLbackpush(&sl, 5);

	SLprint(&sl);
	//if (SLfind(&sl, 100))
	//{
	//	printf("找到了\n");
	//}
	//else
	//{
	//	printf("没有找到\n");
	//}
	int flag = SLfind(&sl, 4);
	Slrandompush(&sl, flag, 9);
	SLprint(&sl);
	//SLrandompop(&sl, flag);
	//SLprint(&sl);

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

五.结言

这就是我们顺序表的实现内容了，当然还有一些其他的功能，但都是万变不离其中。无非就是插入与删除其中要注意我们元素的位置移动。但有了这些功能对于大部分的问题都可以解决了。

下一篇给大家详细讲解一下基于顺序表对通讯录的实现。

如果有喜欢的大家请一键三连感谢了！！！

看到之后肯定会回的。拜拜了！！！

北冥湖畔的燕雀
关注
专栏目录
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
本文将深入探讨如何使用C语言实现顺序表，并重点讲解`realloc`函数在扩展内存时的作用。 首先，我们需要理解顺序表的基本操作，包括创建、插入、删除和查找。在C语言中，我们可以使用结构体来表示顺序表，例如定义...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
顺序表C语言版
iwkxi的博客
03-18 3663
文章目录1.线性表2.顺序表2.1概念及结构2.2接口实现2.2.1 SeqList.h2.2.2 SeqList.c2.2.2.1 初始化顺序表 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一
顺序表（C语言版）
m0_64520498的博客
10-13 1715
静态顺序表：以定长数组储存元素 ；动态顺序表：使用动态开辟的数组储存
C语言实现顺序表
辰多代码的博客
07-26 2309
1.2 SeqList.c 1.3 test.c 二、顺序表的实现 2.1 顺序表 创建一个顺序表结构体，成员包含顺序表地址、长度、大小，用于创建顺序表变量。 将顺序表变量的地址传参，通过指针接收对顺序表的顺序表数组初始化为空，长度为0，大小为0。 同样传地址，要先断言指针是否为空，不然会出异常。然后判断顺序表大小是否为0，为0则代表顺序表中没有有效元素，打印提示，并返回函数，如果大于0，则有元素，从下标0开始，打印size个顺序表元素，并用空格相隔。 当我们结束程序
顺序表C语言实现详解
hurryddd
04-03 3082
1、线性表 线性表。全名为线性存储结构，可以理解为即“把所有数据用一根线儿串起来，再存储到物理空间中”。线性表并不是一种具体的存储结构，它包含 顺序存储结构 和 链式存储结构，是顺序表和链表的统称。除了数组，链表、队列、栈等也是线性表结构。 顺序存储结构：将数据依次存储在连续的整块物理空间中 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系 非线性表。在非线性表中，数据之间并不是简单的前后关系。比如树、图 2、顺序表 它用一组连续的内存空间，来存储一组具有
C语言链表超详解
热门推荐
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 7509
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
顺序链表C语言实现
zcg_741454897的博客
11-04 3357
顺序链表没什么说的啦，直接上代码，参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了，不过没关系，都一样。 Operation中有一处语法上的疑惑，就是插入的那个函数中，node为什么要强制转换成整型，既然等式两边都是指针，为什么不是转化成int* ，有心人帮忙解答一下，谢谢。 SeqList.h头文件 #ifndef _SEQLIST_H_ #define _SEQLIST_...
初识数据结构——链表和顺序表（C语言）
shi_ki2的博客
05-15 880
数据结构顾名思义就是数据在计算机中的存储结构，当然数据结构有很多种（线性结构，树状结构，网状结构），今天我们只介绍最基础的两种线性结构——顺序表和链表。
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 3077
轻松带你搞定顺序表！
顺序表详解（C语言版）
qq_44075108的博客
09-27 2万+
本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C语言实现顺序表的合并
12-23
C语言数据结构实现顺序表的动态申请内存并且合并，代码可以直接使用。
39 C 语言枚举类型、枚举常量、枚举变量、枚举的遍历、枚举数组、枚举与 switch
Thanks_ks的IT探秘之旅
10-05 986
本文全面介绍了枚举（Enum）在编程中的基本概念与用法。首先阐述了枚举的定义及其类型，包括语法格式、枚举元素的特点，并通过案例演示了如何定义枚举类型。接着，深入探讨了枚举变量的概念、定义方式及其实战应用。文章还详细讲解了枚举的遍历方法，包括连续和非连续枚举常量的遍历技巧。此外，还介绍了枚举在 switch 语句中的使用以及枚举数组的相关知识。本文旨在帮助读者深入理解枚举，并能在实际编程中灵活运用。
《数据结构》--队列【各种实现，算法推荐】
Stark的博客
10-06 775
队列是一种常见的数据结构，按照先进先出（FIFO，First In First Out）的原则排列数据。也就是说，最早进入队列的元素最先被移除。：将元素添加到队列的尾部。：从队列的头部移除并返回元素。：初始化一个空队列。：返回但不移除队列的头部元素（通常称为“peek”或“front”）。：检查队列中是否还有元素。：返回队列中元素的数量。
数据结构之图（6）
2301_76246515的博客
10-05 1000
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 467
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
【数据结构 | PTA】表
最新发布
等风来
10-08 778
例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。
C语言动态顺序表实现详解
"这篇资源是关于C语言实现动态顺序表的代码示例，动态顺序表是一种根据需要在内存中动态扩展存储容量的数据结构。代码包括了动态顺序表的基本操作，如初始化、添加元素（PushBack和PushFront）、删除元素（PopBack和...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值