数据结构之顺序表

已于 2024-07-10 23:08:15 修改
阅读量501 收藏 5
点赞数 9
分类专栏： 数据结构（初阶） 文章标签： 数据结构
于 2024-07-10 15:18:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73634434/article/details/140322052
版权

在了解顺序表之前我们需要先了解什么是线性表

1.线性表的定义

线性表(Linear List)：是n个具有相同特征的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串

线性表在逻辑上是线性结构，也就是说一条连续的直线。但在物理结构上并不一定是连续的

线性表在物理上存储时，通常以数组和链式结构的形式存储

2.顺序表

2.1顺序表的概念以及结构

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

4a19b95a8d264555980cecb3964d76fd.png

2.2顺序表的类型

->1.静态顺序表：使用定长数组存储元素

294f32ab83da4858b78e2b3f6a426a15.png

开辟一个固定长度的数组，向数组中存储数据

缺点：

这样开辟的顺序表空间是固定的，如果我们需要存储的空间大于这个固定空间，那我们就需要重新来开辟空间，如果我们只需要存放几个数据，那就会浪费不少空间

->2.动态顺序表：使用动态开辟的数组存储

135e3c2099244150ae78bb4f7c3ee43a.png

相比于静态顺序表的优点：

更加的灵活，不会出现空间不足或者浪费大量空间的情况，所以现实中基本都是使用动态顺序表

下面我们实将现动态顺序表

3.顺序表的增删查改

->1.实现顺序表所需要用到的接口

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define INIT_CAPACITY 4
typedef int SLDATATYPE;


//初始化
void INITSeqList(SL* ps);

//清除顺序表
void SLDestroy(SL* ps);

//增容
void IncrCapacity(SL* ps);

//打印
void print(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDATATYPE x);

//尾删
void SLPopBack(SL* ps);

//头插
void SLPushFront(SL* ps, SLDATATYPE x);

//头删
void SLPopFront(SL* ps);

//顺序表再pos处增加元素
void SLInsert(SL* ps, SLDATATYPE pos, SLDATATYPE x);

//顺序表删除再pos位置的元素
void SLErase(SL* ps, SLDATATYPE pos);

//查找元素
int SLFind(SL* ps, SLDATATYPE x);

->2.顺序表的创建

//顺序表的动态存储
typedef struct SeqList
{
	SLDATATYPE* a;
	int size;       //有效数据的个数
	int capacity;	//空间容量
 }SL;

->3.初始化

//顺序表初始化
void INITSeqList(SL* ps)
{
	assert(ps);

	ps->a = (SLDATATYPE*)malloc(sizeof(int) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("INITSeqList::malloc");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

->4.销毁数据表

//销毁顺序表
void SLDestroy(SL* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

->5.在进行增删的时候检查一下空间是否为满

//检查容量是否已满
void SLCheckCapacity(SL* ps)
{
	assert(ps);

	if (ps->size == ps->capacity)
	{
		SLDATATYPE* ptr = (SLDATATYPE*)realloc(ps->a, sizeof(int) * (INIT_CAPACITY * 2));
		if (NULL == ptr)
		{
			perror("IncrCapacity::realloc");
			return;
		}
		ps->a = ptr;
		ps->capacity *= 2;
	}
}

->6.打印

//打印内容
void print(SL* ps)
{
	assert(ps);

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

->7.头插

//头插
void SLPushFront(SL* ps, SLDATATYPE x)
{
	assert(ps);

	SLCheckCapacity(ps);
    //整体向后移动
	for (int end = ps->size - 1; end >= 0; --end)
	{
		ps->a[end + 1] = ps->a[end];
	}

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

->8.头删

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

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

->9.尾插

//尾插
void SLPushBack(SL* ps, SLDATATYPE x)
{
	assert(ps);

	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;
}

->10.尾删

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

	ps->a[ps->size--] = 0;
}

->11.在顺序表pos处增加元素

//在顺序表pos处增加元素
void SLInsert(SL* ps, SLDATATYPE pos, SLDATATYPE x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);

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

->12.删除在pos位置的元素

//顺序表删除再pos位置的元素
void SLErase(SL* ps, SLDATATYPE pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	SLDATATYPE begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin] = ps->a[begin - 1];
		++begin;
	}
	--ps->size;
}

->13.顺序表查找

//查找
int SLFind(SL* ps, SLDATATYPE x)
{
	assert(ps);
	for (int i = 0; i < ps->size - 1; ++i)
	{
		if (ps->a[i] == x)
			printf("找到了！！！%d\n", i);
	}
	return -1;
}

4.源代码

->1.test.c

#include "SeqList.h"


int main()
{
	SL a;
	INITSeqList(&a);
	test();
	int input = -1;

	//尾插
	SLPushBack(&a,1);
	print(&a);
	SLPushBack(&a, 2);
	print(&a);
	SLPushBack(&a, 3);
	print(&a);
	SLPushBack(&a, 4);
	print(&a);

	//尾删
	SLPopBack(&a);
	print(&a);

	//在pos位置插入8
	SLInsert(&a, 3, 8);
	print(&a);

	//查找该元素的位置，返回下标
	int pos = SLFind(&a, 2);

	return 0;
}

->2.SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define INIT_CAPACITY 4
typedef int SLDATATYPE;

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

//初始化
void INITSeqList(SL* ps);

//清除顺序表
void SLDestroy(SL* ps);

//增容
void IncrCapacity(SL* ps);

//打印
void print(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDATATYPE x);

//尾删
void SLPopBack(SL* ps);

//头插
void SLPushFront(SL* ps, SLDATATYPE x);

//头删
void SLPopFront(SL* ps);

//顺序表再pos处增加元素
void SLInsert(SL* ps, SLDATATYPE pos, SLDATATYPE x);

//顺序表删除再pos位置的元素
void SLErase(SL* ps, SLDATATYPE pos);

//查找元素
int SLFind(SL* ps, SLDATATYPE x);

->3.SeqList.c

#include "SeqList.h"

//顺序表初始化
void INITSeqList(SL* ps)
{
	assert(ps);

	ps->a = (SLDATATYPE*)malloc(sizeof(int) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("INITSeqList::malloc");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

//清除顺序表
void SLDestroy(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

//打印内容
void print(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

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

//检查容量是否已满
void SLCheckCapacity(SL* ps)
{
	assert(ps);

	if (ps->size == ps->capacity)
	{
		SLDATATYPE* ptr = (SLDATATYPE*)realloc(ps->a, sizeof(int) * (INIT_CAPACITY * 2));
		if (NULL == ptr)
		{
			perror("IncrCapacity::realloc");
			return;
		}
		ps->a = ptr;
		ps->capacity *= 2;
	}
}


//尾插
void SLPushBack(SL* ps, SLDATATYPE x)
{
	assert(ps);

	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;
}

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

	ps->a[ps->size--] = 0;
}


//头插
void SLPushFront(SL* ps, SLDATATYPE x)
{
	assert(ps);

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

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

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

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

//在顺序表pos处增加元素
void SLInsert(SL* ps, SLDATATYPE pos, SLDATATYPE x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);

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

//删除顺序表pos处的元素
void SLErase(SL* ps, SLDATATYPE pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	SLDATATYPE begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin] = ps->a[begin - 1];
		++begin;
	}
	--ps->size;
}

//查找
int SLFind(SL* ps, SLDATATYPE x)
{
	assert(ps);
	for (int i = 0; i < ps->size - 1; ++i)
	{
		if (ps->a[i] == x)
			printf("找到了！！！%d\n", i);
	}
	return -1;
}

测试结果：

61bd360e84d441d7bcddb6c72fefce58.png

我太想进步了！！
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之顺序表的插入
m0_52201270的博客
12-15 3846
数据结构之链表的插入
超详细讲解数据结构之顺序表
bit_xwg的博客
03-15 2813
超详细讲解数据结构之顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表一般分为静态顺序表和动态顺序表。 静态顺序表 静态顺序表是使用定长数组存储元素。 简单静态顺序表结构体的初始化： #define N 7 typedef int SLDataType; struct Seqlist { SLDataTy
数据结构之顺序表篇
m0_67768006的博客
02-24 3553
顺序表篇
数据结构之顺序表（C语言）
weixin_50803498的博客
10-14 2784
线性表、顺序表、线性表存储结构、顺序表初始化、顺序表数据插入、顺序表数据删除、按位插入、按位删除、顺序表的使用场景、适合场景、不适合场景
数据结构之顺序表的增删查改
2301_79551553的博客
01-21 2544
假如我们每次扩2个或3个，那很容易就会不够，扩容很频繁，导致性能消耗，如果一次扩1000个，2000个又很容易空间浪费，但如果我们以倍数扩容，随着空间越来越大每次增加的空间也会越来越大，这样扩容就不会很频繁，浪费空间也不会很多，我们通常是采用2倍扩容或1.5倍扩容，至于为什么是这俩数字就涉及到数学原理了，我能力有限，无法作答。ok，至此，我们知道了什么是顺序表，顺序表的增删查改四种功能我们也都实现了，可以说是迈出了相当大的一步，下一次我们将会在此基础上实现通讯录，但是在物理结构上并不⼀定是连续的，
数据结构之顺序表（C语言版）
qq_59343045的博客
07-16 2966
静态顺序表的部分简单操作
【数据结构】顺序表详解
胡坚涛的博客
11-11 1634
数据结构之顺序表详解
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9663
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
数据结构（顺序表）
小马同学的博客
11-07 2369
数据机构的顺序表实现
C#数据结构之顺序表(SeqList)实例详解
01-01
本文实例讲述了C#数据结构之顺序表(SeqList)实现方法。分享给大家供大家参考，具体如下： 线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征用图形表示如下： 即：每个元素前面有且只有...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 453
AVL树
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 955
详解了推有关的两个面试题：堆排序，TopK问题
栈—数据结构
weixin_63722559的博客
09-06 950
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
数据结构：（LeetCode203）移除链表元素
2303_81073778的博客
09-06 381
请你删除链表中所有满足。给你一个链表的头节点。
【数据结构】基本概念和术语
最新发布
Sakura_ding的博客
09-09 734
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
数据结构 栈 队列
qq_69971969的博客
09-06 613
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
数据结构之顺序表操作详解-以C语言为例
"顺序表操作的典型例子-C语言数据结构课件【比较清晰】" 在计算机科学中，数据结构是编程的重要组成部分，它涉及到如何有效地组织和存储数据，以便进行高效的检索、插入和删除等操作。这个课件特别关注的是顺序表的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值