数据结构——顺序表

最新推荐文章于 2024-04-07 15:41:53 发布
最新推荐文章于 2024-04-07 15:41:53 发布
阅读量762 收藏 25
点赞数 29
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx2023_10_15/article/details/136586080
版权

1. 顺序表的结构和概念

1.1 线性表

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

  顺序表在逻辑结构上和物理结构上都是线性的

1.2 顺序表的结构

 顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接口。  

顺序表又分为静态顺序表和动态顺序表

1.2.1 静态顺序表

结构如下：

typedef int SLDataType;
#define N 10
typedef struct SeqList
{
	SLDataType arr[N];  //定长数组
	int size;           //有效元素个数
}SL;

静态顺序表缺陷：空间给少了不够用，给多了造成空间浪费。


1.2.2 动态顺序表

结构如下：

typedef int SLDataType;
typedef struct SeqList
{
	struct SeqList* p;
	int size;       //有效数据个数
	int capacity;   //空间容量
}SL;//按需申请

 注：

  • typedef int SLDataType;用typedef 对类型进行重命名，是为了方便以后修改代码。
  • 我们一般使用动态顺序表，因为它可以按我们需求申请空间      

 2. 动态顺序表的实现

2.1 动态顺序表的创建

typedef int SLDataType;
typedef struct SeqList
{
	struct SeqList* p;  //存储数据的底层结构
	int capacity;       //记录顺序表的空间大小
	int size;           //记录顺序表当前有效的数据个数
}SL;                    //按需申请

2.2 顺序表的初始化和打印

2.2.1 初始化

SeqList.h：

void SLInit(SL* ps);

 SeqList.c：

void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

2.2.3 打印

SeqList.h：

void SLPrint(SL* ps)；

 SeqList.c：

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

2.3 扩容

当我们申请的空间不够时，我们需要对顺序表进行扩容。

扩容的方式有三种：

  1. 一次扩容一个空间：插入一个元素还不会造成空间浪费；
  2. 一次扩容固定个大小的空间（10/100...）
  3. 成倍数的增加（1.5倍、2倍）

 我们一般使用第三种方法，因为第一种方法程序执行效率低下；第二种方法申请空间太小造成频繁扩容，太大造成空间浪费。

SeqList.h：

void SLCheckCapacity(SL* ps);

 SeqList.c：

void SLCheckCapacity(SL* ps)
{
	int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
	SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
	if (tmp == NULL)
	{
		perror("realloc fall!");
		exit(1);
	}
	ps->arr = tmp;
	ps->capacity = newcapacity;
}

2.4 顺序表的插入

2.4.1 尾插

SeqList.h：

void SLPushBack(SL* ps, SLDataType x);

SeqList.c：

void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，直接插入
	ps->arr[ps->size++] = x;
}
//头插

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPushBack(&sl, 5);
	SLPrint(&sl);

}

测试结果如下：

2.4.2 头插

 SeqList.h：

void SLPushFront(SL* ps, SLDataType x)；

SeqList.c：

//头插
void SLPushFront(SL* ps, SLDataType 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++;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 6);
	SLPushFront(&sl, 7);
	SLPushFront(&sl, 8);
	SLPrint(&sl);

}

测试结果如下：

 2.5 顺序表的删除

2.5.1 尾删

SeqList.h：

void SLPopBack(SL* ps)；

SeqList.c：

void SLPopBack(SL* ps) {
	assert(ps);
	//判断顺序表是否为空
	assert(ps->size);
	//不为空
	ps->size--;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPrint(&sl);

}

2.5.2 头删

SeqList.h：

void SLPopFront(SL* ps)；

SeqList.c：

void SLPopFront(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--;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPrint(&sl);

}

 测试结果如下：

 2.6 在指定位置插入数据

 SeqList.h：

void SLInsert(SL* ps, int pos, SLDataType x)

SeqList.c：

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps && (pos>=0&&pos <= ps->size));
	//判断是否扩容
	SLCheckCapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i ] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLInsert(&sl, 3, 100);
	SLPrint(&sl);

}

2.7 在指定位置删除

SeqList.h：

void SLErase(SL* ps, int pos)

SeqList.c：

void SLErase(SL* ps, int pos)
{
	assert(ps && (pos >= 0 && pos <= ps->size));
	//判断顺序表是否为空
	assert(ps->size);
	//不为空
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];

	}
	ps->size--;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	SLErase(&sl, 2);
	SLPrint(&sl);

}

测试结果如下：

注意：删除的是对应下标的的数据。 

 2.8 查找数据

SeqList.h：

int SLFind(SL* ps, SLDataType x)；

SeqList.c：

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

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	int ret = SLFind(&sl, 3);
	if (ret < 0)
	{
		printf("数据不存在，查找失败！");
	}
	else
	{
		printf("数据找到了，在下标%d位置\n", ret);
	}
}

测试结果如下：

 2.9 顺序表的销毁

SeqList.h：

void SLDestory(SL* ps)；

SeqList.c：

void SLDestory(SL* ps)
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

test.c：

void SLTest() {
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLDestory(&sl);
}

测试结果如下：

3. 顺序表的完整代码

SeqList.h：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int capacity;
	int size;
}SL;
//初始化和打印
void SLInit(SL* ps);
void SLPrint(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);
//头插和尾插
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//头删和尾删
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//在指定位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x);
//在指定位置删除
void SLErase(SL* ps, int pos);
//查找数据
int SLFind(SL* ps, SLDataType x);
//销毁
void SLDestory(SL* ps);

SeqList.c：

#include "SeqList.h"
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
//检查内存空间，扩容
void SLCheckCapacity(SL* ps)
{
	int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
	SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
	if (tmp == NULL)
	{
		perror("realloc fall!");
		exit(1);
	}
	ps->arr = tmp;
	ps->capacity = newcapacity;
}
//尾插
void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，直接插入
	ps->arr[ps->size++] = x;
}
//头插
void SLPushFront(SL* ps, SLDataType 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++;
}
//尾删
void SLPopBack(SL* ps) {
	assert(ps);
	//判断顺序表是否为空
	assert(ps->size);
	//不为空
	ps->size--;
}
//头删
void SLPopFront(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--;
}
//在指定位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps && (pos>=0&&pos <= ps->size));
	//判断是否扩容
	SLCheckCapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i ] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//在指定位置删除
void SLErase(SL* ps, int pos)
{
	assert(ps && (pos >= 0 && pos <= ps->size));
	//判断顺序表是否为空
	assert(ps->size);
	//不为空
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];

	}
	ps->size--;
}
//查找数据

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void SLDestory(SL* ps)
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

 

本文为作者学习《顺序表》后的总结，如果有什么不恰当的地方，欢迎大佬指正！！！

未梦来
关注
  • 29
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
数据结构实验——顺序表
12-22
数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表
数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
数据结构——顺序表（C语言编写）
新手小白
09-17 7848
数据结构，顺序表应用 插入、删除、合并...
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 2933
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构 ——顺序表【c语言版】
clear-ninghongkang的博客
11-19 5976
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的顺序存储结构———顺序表 顺序存储结构——逻辑上相邻的元素，在物理上也相邻 在c语言中，顺序表通常用数组来存储，这与python中的列表不同，数组是给定长度的，数组中元素的地址也是相邻的，且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的，(因为pyt...
数据结构——顺序表的逆置
热门推荐
luladuck的博客
03-20 1万+
题目：请写一个算法将顺序存储结构的线性表（a1...an）逆置为(an...a1)，要求使用最少的附加空间。 解析：可以理解为一个线性表内的交换问题。当n为奇数时，将第一个元素与最后一个元素进行交换，第二个元素与倒数第二个元素进行交换，以此类推，最中间的元素不用进行交换（n/2+1）。当n为偶数时，规则与奇数时一样，只是最中间两个元素也要进行交换（n/2 <----> n/2+1）。 核心代码： //核心代码 void Inverse(SqList &L) { int i, t
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6408
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
数据结构 —— 顺序表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-04 3233
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构——顺序表的C语言实现
Winters_coming的博客
10-27 3856
郫县电子专科学院的在读大二，再次保存代码供参考及批评指正 ex1_1——基本题： 1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。 2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。 3）在...
数据结构——顺序表——最大连续1的个数
最新发布
qq_48335434的博客
04-07 249
数据结构——顺序表——最大连续1的个数
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——矩阵.docx
07-11
数据结构——矩阵全文共7页，当前为第1页。数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 软件学院 上机实验报告 课程名称： 数据...
Java数据结构——用顺序表编写一个简易通讯录
05-15
好的，下面是用Java顺序表实现简易通讯录的代码： 首先，在Java中需要定义一个类来表示通讯录中的每一个联系人，这个类包含联系人的姓名和电话号码两个属性： ```java public class Contact { private String ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值