C语言-数据结构之顺序表

已于 2024-07-03 13:01:06 修改
阅读量415 收藏 8
点赞数 14
文章标签： c语言 数据结构 开发语言
于 2024-01-29 20:47:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81486828/article/details/135920498
版权
本文详细介绍了顺序表的定义，包括静态和动态两种形式，以及其接口的实现，如初始化、销毁、打印、扩容检查、增加（尾插、头插、指定位置）、删除（尾删、头删、指定位置）和查找功能。重点展示了如何在SeqList.h和SeqList.c文件中实现这些功能。
摘要由CSDN通过智能技术生成
一.顺序表定义

目录

一.顺序表定义

1.线性表

2.顺序表的定义和分类

二.接口的实现

1.准备工作及其注意事项

2.顺序表的基本功能接口

2.1 顺序表的初始化

2.2 顺序表的销毁

2.3 顺序表的打印

3.顺序表的扩容检查接口

4.顺序表的增加功能接口

4.1 尾插接口

4.2 头插接口

4.3 指定位置插入接口

5.顺序表的删除功能接口

5.1 尾删接口

5.2头删接口

5.3指定位置删除接口

6.顺序表的查找实现接口

三.总代码概览

SeqList.h文件

SeqList.c文件

1.线性表
线性表（ linear list ）是n个具有相同特性的数据元素的有限序列, 线性表是⼀种在实际中⼴泛使
⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，
线性表在物理上存储时，通常以数组和链式结构的形式存储。
简单来说顺序表是线性表的一种,而且逻辑和物理都是线性结构
2.顺序表的定义和分类

顺序表的底层是数组,通过增加一些增删查找等接口实现

2.1 静态顺序表

静态顺序表(这里拿里面存储的整形举例)
typedef int SLDataType;
#define N 100
typedef struct SeqList
{
    SLDatatype arr[N];
    int size;//size是有效数据的个数
}SL;

解释一下为什么要把存储的类型变为SLDataType
这么做是为了方便以后修改
还有把数组存储的数据容量便于修改

2.2 动态顺序表

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;
}SL;//这里我们定义了一个结构体,其实这就是一个动态的顺序表

因为动态顺序表的结构更加灵活,所以我们下面的接口都是通过动态顺序表实现的

二.接口的实现
1.准备工作及其注意事项

我们需要创建3个文件

我先来解释一下这三个文件的作用,头文件SeqList.h是来声明接口以及定义顺序表

源文件SeqList.c是用来具体实现接口,源文件test.c用于接口的测试工作

注意事项几条小点
1.不管是任意一种操作我们在处理之前都要判段  assert(ps->arr) ;
2.在进行扩容的时候别忘记了  要把容量变成新开出来的那个 
3.进行插入操作之后  要把size++;  在进行删除操作的时候要进行size--;
4.进行删除操作的时候  除了要判断第一种断言之外,还要在判断 assert(ps->size) 
5.进行指定位置插入或者删除的时候,要进行判断pos的范围问题

小拓展:
1.尝试用memmove函数覆盖数据 
2.for循环的使用方法其实只看头尾即可 
3.尝试用while循环代替for循环实现
4.进行移动的时候方向问题的判断就是是否会有重叠  

2.顺序表的基本功能接口
2.1 顺序表的初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
2.2 顺序表的销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
2.3 顺序表的打印
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0;i < ps->size;++i)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
3.顺序表的扩容检查接口

这个接口在进行增加元素的时候,需要用到,因为不确定空间是否足够

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
	if (ps->capacity == ps->size)
	{
		SLDataType* ptr = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newCapacity);
		if (ptr == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = ptr;
		ps->capacity = newCapacity;
	}
}
4.顺序表的增加功能接口
4.1 尾插接口
void SLPushBack(SL* ps,int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	ps->arr[ps->size] = x;//经过判断是否扩容之后,直接插入arr[size]的位置
}
4.2 头插接口

我们给三种实现方式,循环实现的时候,从头部遍历还是尾部遍历要看元素是否有重叠

//01(for循环实现)
void SLPushFront01(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	for (int i = ps->size;i > 0;--i) 
	{
		ps->arr[i] = ps->arr[i - 1];
	}//只看头尾进行判断
	ps->arr[0] = x;
	ps->size++;
}
//02(while循环实现)
void SLPushFront02(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	int begin = ps->size;
	while (begin > 0) 
	{
		ps->arr[begin] = ps->arr[begin - 1];
		begin--;
	}
	ps->arr[0] = x;
	ps->size++;
}
//03(内存操作函数memmove实现)
void SLPushFront03(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	memmove((ps->arr) + 1, ps->arr, sizeof(SLDataType) * ps->size);
	ps->arr[0] = x;
	ps->size++;
}
4.3 指定位置插入接口

这个与上面的头插类似

//01for循环实现
void SLInsert01(SL* ps, int pos, int x)
{
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size;i > pos;--i)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//02while循环实现
void SLInsert02(SL* ps, int pos,int x)
{
	assert(ps);
	int begin = ps->size;
	while (begin > pos)
	{
		ps->arr[begin] = ps->arr[begin - 1];
		begin--;
	}
	ps->arr[pos] = x;
	ps->size++;
}
//03memmove内存操作函数实现
void SLInsert03(SL* ps, int pos, int x)
{
	assert(ps);
	memmove(ps->arr + pos, ps->arr + pos + 1, sizeof(SLDataType) * (ps->size - pos));
	ps->arr[pos] = x;
	ps->size++;
}
5.顺序表的删除功能接口
5.1 尾删接口
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}
5.2头删接口
//01for循环实现
void SLPopFront01(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0;i < ps->size - 1;++i)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//02while循环实现
void SLPopFront02(SL* ps)
{
	assert(ps);
	assert(ps->size);
	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->arr[begin] = ps->arr[begin + 1];
	}
	ps->size--;
}
//03memmove内存操作函数实现
void SLPopFront03(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDataType) * (ps->size - 1));
	ps->size--;
}
5.3指定位置删除接口
//01for循环实现
void SLErase01(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	for (int i = pos;i < ps->size-1;++i)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//02while循环实现
void SLErase02(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	int begin = pos;
	while (begin < pos - 1)
	{
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}
//03memmove内存操作函数实现
void SLErase03(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	memmove(ps ->arr, ps->arr + 1, sizeof(SLDataType) * (ps->size - pos - 1));
	ps->size--;
}
6.顺序表的查找实现接口
int SLFind(SL* ps, int x)
{
	for (int i = 0;i < ps->size;++i)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}
三.总代码概览
SeqList.h文件
#pragma once
#include<memory.h>
//这里的头文件进行的顺序表的声明
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;
}SL;//这里我们定义了一个结构体,其实这就是一个动态的顺序表

void SLInit(SL* ps);//顺序表的初始化
void SLPrint(SL* ps);//顺序表的打印
void SLDestroy(SL* ps);//顺序表的销毁

void SLCheckCapacity(SL* ps);//顺序表的扩容检查(扩容的原则,以及扩容的方法)

void SLPushBack(SL* ps,int x);//顺序表的尾插
//顺序表的头插
void SLPushFront01(SL* ps, int x);
void SLPushFront02(SL* ps, int x);
void SLPushFront03(SL* ps, int x);
//顺序表的指定位置插入(这里的指定位置我们指的是下标前面)
void SLInsert01(SL* ps, int pos, int x);
void SLInsert02(SL* ps, int pos, int x);
void SLInsert03(SL* ps, int pos, int x);

void SLPopBack(SL* ps);//顺序表的尾删
void SLPopFront(SL* ps);//顺手表的头删
void SLErase(SL* ps,int pos);//顺序表的指定位置删除
SeqList.c文件
#include<stdio.h>
#include<assert.h>
#include<memory.h>
#include"SeqList.h"
//这里的源文件我们进行的头文件中的函数的具体实现
//也就是封装相关的函数

//1.顺序表的初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
//2.顺序表的打印
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0;i < ps->size;++i)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
//3.顺序表的销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//4.顺序表的扩容检查(扩容的原则,以及扩容的方法)
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
	if (ps->capacity == ps->size)
	{
		SLDataType* ptr = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newCapacity);
		if (ptr == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = ptr;
		ps->capacity = newCapacity;
	}
}

//5.顺序表的尾插
void SLPushBack(SL* ps,int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	ps->arr[ps->size] = x;//经过判断是否扩容之后,直接插入arr[size]的位置
}
//6.顺序表的头插
//01(for循环实现)
void SLPushFront01(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	for (int i = ps->size;i > 0;--i) 
	{
		ps->arr[i] = ps->arr[i - 1];
	}//只看头尾进行判断
	ps->arr[0] = x;
	ps->size++;
}
//02(while循环实现)
void SLPushFront02(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	int begin = ps->size;
	while (begin > 0) 
	{
		ps->arr[begin] = ps->arr[begin - 1];
		begin--;
	}
	ps->arr[0] = x;
	ps->size++;
}
//03(内存操作函数memmove实现)
void SLPushFront03(SL* ps, int x)
{
	assert(ps);
	SLCheckCapacity(ps);//判断以下是否需要扩容
	memmove((ps->arr) + 1, ps->arr, sizeof(SLDataType) * ps->size);
	ps->arr[0] = x;
	ps->size++;
}
//7.顺序表的指定位置插入
//01for循环实现
void SLInsert01(SL* ps, int pos, int x)
{
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size;i > pos;--i)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//02while循环实现
void SLInsert02(SL* ps, int pos,int x)
{
	assert(ps);
	int begin = ps->size;
	while (begin > pos)
	{
		ps->arr[begin] = ps->arr[begin - 1];
		begin--;
	}
	ps->arr[pos] = x;
	ps->size++;
}
//03memmove内存操作函数实现
void SLInsert03(SL* ps, int pos, int x)
{
	assert(ps);
	memmove(ps->arr + pos, ps->arr + pos + 1, sizeof(SLDataType) * (ps->size - pos));
	ps->arr[pos] = x;
	ps->size++;
}

//8.顺序表的头删
//01for循环实现
void SLPopFront01(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0;i < ps->size - 1;++i)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//02while循环实现
void SLPopFront02(SL* ps)
{
	assert(ps);
	assert(ps->size);
	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->arr[begin] = ps->arr[begin + 1];
	}
	ps->size--;
}
//03memmove内存操作函数实现
void SLPopFront03(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDataType) * (ps->size - 1));
	ps->size--;
}
//9.顺序表的尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}
//10.指定位置删除
//01for循环实现
void SLErase01(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	for (int i = pos;i < ps->size-1;++i)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//02while循环实现
void SLErase02(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	int begin = pos;
	while (begin < pos - 1)
	{
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}
//03memmove内存操作函数实现
void SLErase03(SL* ps, int pos)
{
	assert(ps);
	assert(ps->size);
	memmove(ps ->arr, ps->arr + 1, sizeof(SLDataType) * (ps->size - pos - 1));
	ps->size--;
}

//查找接口的实现
int SLFind(SL* ps, int x)
{
	for (int i = 0;i < ps->size;++i)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

浅念同学
关注
  • 14
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
数据结构c语言版 顺序表部分代码
03-01
源文件 博文链接：https://thebigforest.iteye.com/blog/43206
c语言数据结构之顺序表
xyz的博客
03-12 1105
c语言数据结构之顺序表：    顺序表的结构跟数组比起来还是很像的，相比于链表，数据表的优势主要体现在他的查询速度上，而链表的优势相反，查询速度慢，但对于插入一个数据来说还是比较快的下面我们就来创建一个顺序表1：定义数据类型，我定义的是一个学生的结构体类型，首先先宏定义一个sizemax的不变量，代表顺序表的最大长度，typedef也是一个宏定义，定义好后就可以用ElemType代替STU了，当然...
C语言数据结构——顺序表
2302_77788717的博客
01-20 371
线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列....
【C语言】--数据结构--顺序表
weixin_64609308的博客
05-13 750
此博客会涉及顺序表的概念以及顺序表的模拟
c语言实现数据结构中的顺序表
qq_68695298的博客
08-28 1027
包看包会的c语言实现数据结构中的顺序表，十分口语化也十分的详细。
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言顺序表知识点 根据提供的PPT课件，以下是相关的知识点： 1. 线性表的逻辑结构 * 线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。 * 线性表的逻辑结构可以用以下形式表示：L=(a1, a2,...,...
数据结构-C语言描述（顺序表、链表）
04-01
### 数据结构-C语言描述（顺序表、链表） #### 实验背景 本次实验的主要目的是让学生通过C语言实现顺序表和链表的相关操作，加深对这两种基本数据结构的理解，并掌握其在实际编程中的应用技巧。 #### 实验目的 1...
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
最新发布
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构c语言版严蔚敏 顺序表
qq_40427276的博客
02-21 2877
说来惭愧由于贪玩，数据结构挂科了，现在重新学一遍数据结构，用博客督促一下自己，希望各位同学引以为戒，贪玩一时爽，痛苦永留存。 本文主要以严老师的数据结构书为主。 结构类型 listsize代表这个顺序表的最大容量 可以随时扩容 length代表表中元素个数 应小于listsize 1.初始化 Status list_init(SqList &L) { L.elem...
C语言——顺序表
学习C++的小陈同学
11-23 533
C语言实现顺序表
C语言实现顺序表
热门推荐
qq_42204238的博客
03-31 4万+
c语言实现顺序表 线性表是最简单的数据结构，而顺序表又是最简单的线性表，其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素，比如我们常用的一位数组，下面代码实现了顺序表的定义以及基本操作。 编译环境：vs2017。 运行试例： 贴代码如下： #include "stdio.h" #include "windows.h" #include "stdlib.h" #define MAXSI...
C语言——顺序表详解
qq_62476499的博客
01-08 528
讲解顺序表的基本功能
顺序表实现的注意点
ba15059695816的博客
09-24 1366
首先，是一些定义，线性表的顺序存储结构称为顺序表（sequential list），用MaxSize表示数组的长度，length表示顺序表的长度，length   进入正题：(i)一般数组的下标是从0开始的（例如C++），而线性表中元素的序号是从1开始的，即顺序表中第i个元素存储在数组中下标为i-1的位置。 (ii)顺序表 （1）按位查找表中第i个元素，1 （2）插入新元素x（前提：如
数据结构入门（二）：顺序表
m0_56695823的博客
10-23 441
1.顺序表的概念 2.接口的实现 3.顺序表的相关面试题 4.顺序表的问题及思考 1.顺序表的概念 顺序表是一种用连续的物理地址存储单元一次存储数据元素的线性结构，所以它和链表、栈、队列、字符串以及都是属于线性表。 1.1顺序表一般可以分为静态顺序表和动态顺序表 静态顺序表： 即给定数组的长度，往里面存储数据 动态顺序表 先给定一定的空间，当空间不够的时候可以扩容； ...
顺序表--C语言版（从0开始，超详细解析 ，小白一听就懂！！！）
weixin_45031801的博客
11-17 5952
⭕ 接口7：头删（SLPopFront） ⭕ 接口12：打印函数（SLPrint）以下就是我对数据结构---顺序表的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对数据结构-------单链表的理解，请持续关注我哦！！！！！
C语言---顺序表（详解）---数据结构
weixin_57535054的博客
02-03 3882
我们直接切入主题 1.首先这次写的顺序表的动态的，因为静态的弊端较多。 2.顺序表的功能函数有：初始化 丶申请动态内存 顺序表的头部，尾部的插入和删除 丶在特定位置的插入和删除 丶打印顺序表 丶释放动态内存 需要用到的头文件 我们先给 类型 重命名 原因是：以后还需要用到顺序表时，插入的不一定是你当前使用的类型，如果要改还需要一个个改，非常麻烦，为了以后方便，我们需要改类型时，直接给 类型重命名 这里改，就可以了，更加节省时间。 创建一个结构体里面包含 1指向动态开辟数组的指针。*a.
【数据结构】【C语言】------- 顺序表
m0_63601181的博客
05-13 2284
前言 大家好，我是Abert。 这篇文章和大家分享C语言实现数据结构的顺序表。顺序表也是之后的数据结构的学习的基础，整体实现过程也不复杂，和通讯录类似。下面我们一起来学习顺序表吧！！！ 文章目录 1、程序基本框架的搭建与讲解 1.1 文件的创建 1.2 变量的创建与声明 2、各种功能的实现及逻辑关系的讲解 2.1 菜单 2.2 尾插 2.3 头插 2.4 尾删 2.5 头删...
[C数据结构]顺序表
weixin_46603347的博客
05-08 604
[C数据结构]顺序表
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值