二.数据结构之顺序表

已于 2023-03-16 14:53:55 修改
阅读量953 收藏 13
点赞数 20
分类专栏： 数据结构 文章标签： 数据结构 c++ c语言
于 2023-02-24 17:04:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67401157/article/details/129164028
版权

文章目录

前言

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

一.顺序表的概念及结构

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

  1. 静态顺序表：使用定长数组存储元素。
#define N 7
typedef int SlDataType;
typedef struct Seqlist
{
	SlDataType array[N];  //定长数组
	size_t size;   //有效数据个数
}Seqlist;

在这里插入图片描述
2. 动态顺序表：使用动态开辟的数组存储。
在这里插入图片描述

二.顺序表的接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，下面我们来实现动态顺序表：

1.顺序表的动态存储

typedef int SLDataType;  //可以是int，double，结构体，按照要求来
#define INIT_CAPACITY 4  //初始化大小为4

typedef struct Seqlist
{
	SLDataType* a;   //指向存放数据的每一个内存空间
	int size;        //有效数据个数
	int capacity;    //空间容量
}SL;

顺序表的长度是不固定的，可增容的，所以要用指针指向每一块信息空间。

2.顺序表的初始化

void SLInit(SL* pc)
{
	assert(pc);
	//1.强制转化类型 2.分配的是字节：sizeof(SLDataType) * INIT_CAPACITY
	pc->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);  //刚开始分配4个
	if (pc->a == NULL)
	{
		perror("malloc");
		return;
	}
	pc->size = 0;
	pc->capacity = INIT_CAPACITY;
}

采用动态分配内存的方式，进行初始化

3.顺序表尾插

void SLPushBack(SL* pc, SLDataType x)
{
	assert(pc);
	//检查是否扩容
	if (pc->size == pc->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(pc->a, sizeof(SLDataType) * pc->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc");
			return;
		}
		pc->a = tmp;
		pc->capacity *= 2;
	}
	//pc->size记录的是当前表中数据的下一位，直接赋值给该位赋值即可
	pc->a[pc->size++] = x;  
}

注意：

  1. realloc函数是按照字节调整大小，所以一定要记得用sizeof 计算类型的字节大小。
  2. pc->a[pc->size++] = x的具体含义如下：
    在这里插入图片描述

改进：上面尾插数据时我们需要检查是否扩容，不如就把扩容函数单独封装，后面再需要检查扩容的时候直接调用该函数即可：

#封装：扩容函数

void SLCheckCapacity(SL* pc)
{
	assert(pc);
	//检查是否扩容
	if (pc->size == pc->capacity)
	{
		//有可能异地扩容，再新定义一个指针
		SLDataType* tmp = (SLDataType*)realloc(pc->a, sizeof(SLDataType) * pc->capacity * 2);
		if (tmp == NULL)
		{
			printf("relloc");
			return;
		}
		pc->a = tmp;
		pc->capacity *= 2;
	}
}

这样尾插函数就可以简化为：

void SLPushBack(SL* pc, SLDataType x)
{
	//assert(pc);
	检查是否扩容
	//if (pc->size == pc->capacity)
	//{
	//	//有可能异地扩容，再新定义一个指针
	//	SLDataType* tmp = (SLDataType*)realloc(pc->a, sizeof(SLDataType) * pc->capacity * 2);
	//	if (tmp == NULL)
	//	{
	//		printf("relloc");
	//		return;
	//	}
	//	pc->a = tmp;  
	//	pc->capacity *= 2;
	//}
	SLCheckCapacity(pc);
	pc->a[pc->size++] = x;
}

4.顺序表尾删

void SLPopBakc(SL* pc)
{
	//暴力的检查
	//assert(pc->size > 0);
	
	//温柔的检查
	if (pc->size == 0)
		return;
	pc->size--;
}

注意：

  1. 当size删到0的时候，我们就没法再删除元素了，否则会出问题，所以在删除元素的时候需要特判一下size的大小，可以用断言assert，也可以用if语句。
  2. **pc->size- -；**的意思是顺序表中元素数量减一，也就是删掉了尾部元素。

5.顺序表头插

//头插
void SLPushFront(SL* pc，SLDataType x)
{
	assert(pc);
	SLCheckCapacity(pc);
	int end = pc->size - 1;  
	while (end >= 0)
	{
		//从最后一位开始，整体把数据后移一位
		pc->a[end + 1] = pc->a[end];
		--end;
	}
	pc->a[0] = x;
	pc->size++;
}

为了给开头腾出位置，需要将数据整体先向后移动一位：

从最后一位开始移动，防止数据被覆盖

6.顺序表头删

//头删
void SLPopFront(SL* pc)
{
	assert(pc);
	assert(pc->size > 0); //保证有数据
	int begin = 1;
	while (begin < pc->size)
	{
		pc->a[begin - 1] = pc->a[begin];
	}
	pc -> size--;
}

删除头部数据前先判断表中是否有数据，表里没东西固然不能硬删。删头元素时是把头元素后面的数据全部往前挪一位，整体覆盖前一个数据，相当于删除了头部元素：
在这里插入图片描述
从第二个开始往前挪，防止提前被覆盖。

7.顺序表查找

//查找
int SLFind(SL* pc, SLDataType x)
{
	assert(pc);
	for (int i = 0; i < pc->size; i++)
	{
		if (pc->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

直接遍历一遍查找即可

8.顺序表在pos位置插入x

//任意位置插入
void SLInsert(SL* pc, int pos, SLDataType x)
{
	assert(pc);
	assert(pos >= 0 && pos <= pc->size);
	SLCheckCapacity(pc);
	int end = pc->size - 1;
	while (end >= pos)
	{
		pc->a[end + 1] = pc->a[end];
		end--;
	}
	pc->a[pos] = x;
	pc->size++;
}

与头插法想法类似，把pos后面的数据整体向后挪动一位，给pos腾出位置来，放入新的值x：
在这里插入图片描述
改进：当pos=0的时候其实就是头插，当pos=pc->size的时候就是尾插
所以我们可以只用一个在任意位置插入的SLInsert函数实现所有位置的数据插入：
①尾插：

void SLPushBack(SL* pc, SLDataType x)
{
	//assert(pc);
	检查是否扩容
	//if (pc->size == pc->capacity)
	//{
	//	//有可能异地扩容，再新定义一个指针
	//	SLDataType* tmp = (SLDataType*)realloc(pc->a, sizeof(SLDataType) * pc->capacity * 2);
	//	if (tmp == NULL)
	//	{
	//		printf("relloc");
	//		return;
	//	}
	//	pc->a = tmp;  
	//	pc->capacity *= 2;
	//}
	/*SLCheckCapacity(pc);
	pc->a[pc->size++] = x;*/
	SLInsert(pc, pc->size, x);
}

②头插

void SLPushFront(SL* pc, SLDataType x)
{
	//assert(pc);
	//SLCheckCapacity(pc);
	//int end = pc->size - 1;  
	//while (end >= 0)
	//{
	//	//从最后一位开始，整体把数据后移一位
	//	pc->a[end + 1] = pc->a[end];
	//	--end;
	//}
	//pc->a[0] = x;
	//pc->size++;
	SLInsert(pc, 0, x);
}

这又能进一步使代码变得简洁

9.顺序表删除pos位置的值

//任意位置删除
void SLErase(SL* pc, int pos)
{
	assert(pc);
	assert(pc >= 0 && pos < pc->size);  //size指向当前数据的下一位，还没有存放数据，所以没东西可删，要注意与任意位置插入的代码区分

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

与头删法类似，采用从pos后往前覆盖的思想，把pos存的数据覆盖住：
在这里插入图片描述
改进：当pos=0时就是头删，当pos=pc->size-1时就是尾删，这样我们可以只用该函数实现任意位置的删除
①尾删：

void SLPopBakc(SL* pc)
{
	//assert(pc);
	暴力的检查
	//assert(pc->size > 0);
	//
	温柔的检查
	//if (pc->size == 0)
	//	return;
	//pc->size--;
	SLErase(pc, pc->size - 1);
}

②头删

//头删
void SLPopFront(SL* pc)
{
	//assert(pc);
	//assert(pc->size > 0); //保证有数据
	//int begin = 1;
	//while (begin < pc->size)
	//{
	//	pc->a[begin - 1] = pc->a[begin];
	//}
	//pc -> size--;
	SLErase(pc, 0);
}

使代码更简洁。

10.顺序表销毁

void SLDestory(SL* pc)
{
	free(pc->a);
	pc->a = NULL;
	pc->capacity = pc->size = 0;
}

由于空间都是动态分配的，所以销毁的时候直接free掉，free后的指针记得置空。

11.顺序表打印

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

三.源

1.Seqlist.h

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

//typedef int SLDataType;
//#define N 100000
//
 静态顺序表 -- 开少了不够用 开多了浪费
//struct SeqList
//{
//	SLDataType a[N];
//	int size;
//};

typedef int SLDataType;
#define INIT_CAPACITY 4

// 动态顺序表 -- 按需申请
typedef struct SeqList
{
	SLDataType* a;
	int size;     // 有效数据个数
	int capacity; // 空间容量
}SL;

// 增删查改
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);
void SLCheckCapacity(SL* ps);

void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

2.Seqlist.c

#include"SeqList.h"
//初始化
void SLInit(SL* ps)
{
	assert(ps);

	ps->a = (SLDataType*)malloc(sizeof(SLDataType)* INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}
//销毁数据
void SLDestroy(SL* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}
//打印数据
void SLPrint(SL* ps)
{
	assert(ps);

	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* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

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

	 扩容
	//SLCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
	//ps->a[ps->size++] = x;

	SLInsert(ps, ps->size, x);
}
//尾删
void SLPopBack(SL* ps)
{
	//assert(ps);

	 暴力检查
	//assert(ps->size > 0);

	 温柔的检查
	if (ps->size == 0)
	//	//return;

	ps->a[ps->size - 1] = 0;
	//ps->size--;

	SLErase(ps, ps->size-1);
}
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	/*assert(ps);

	SLCheckCapacity(ps);

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

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

	SLInsert(ps, 0, x);
}
//头删
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--;

	SLErase(ps, 0);
}
//任意位置插入
void SLInsert(SL* ps, int 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];
		--end;
	}

	ps->a[pos] = x;
	ps->size++;
}
//任意位置删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

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

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

	return -1;
}

四.顺序表的问题及思考

  1. 中间或头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

要解决上述问题，就要用到链表的知识了，我们下一篇再见！！

码文不易，还请多多支持哦！！

殿下p
关注
  • 20
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 30
    评论
专栏目录
数据结构之顺序表.rar
04-07
顺序表是一种基本的数据结构，它是线性表的一种存储方式，其中元素在计算机内存中的存储是连续的，就像一串珠子一样串联在一起。在C++中实现顺序表，我们需要掌握以下几个核心知识点： 1. **数组基础**：顺序表的...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
数据结构002 - 线性表（顺序表）
疯狂的豆子的博客
04-13 1135
数据结构002 - 线性表（顺序表）
数据结构-顺序表
weixin_58165485的博客
03-09 1470
1.顺序表的定义 要理解何为顺序表，先要知道什么是线性表 线性表是具有相同数据类型的 n (n>0)个数据元素的有限序列 若用 L 命名线性表，则其一般表示为： 从这里可以体现出线性表的几个特点 ： 存在唯一的首元素(表头元素)和尾元素(表尾元素) 除第一个元素外，每个元素有且仅有一个直接前驱 除最后一个个元素外，每个元素有且仅有一个直接后继 下面这个表就是一个线性表： 1 2 3 4 5 对于表头元素1，只有一个后继元素2 对于元素2，只有一个.
顺序表详解
qq_40395404的博客
11-21 493
定长顺序表定义： #pragma once #define SIZE 10 typedef struct SeqList { int elem[SIZE]; //顺序表表示数组，总大小SIZE int length; //有效数据的个数 }SeqList,*PSeqList; 操作： //初始化 长度置0即可 void InitSeqList(PSeqList ps) {...
顺序表（数据结构）
outdated_socks的博客
04-07 5404
顺序表详解
数据结构-（顺序表篇）
B_Small_panda的博客
01-14 970
数据结构-顺序表篇
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
数据结构-顺序表.zip
11-03
压缩包中共有两个文件，一个是顺序表的执行代码cpp文件，一个是顺序表的word文件，顺序表的word文件中写有代码所拥有的功能以及各功能的代码的执行结果图片，代码实现了顺序表的初始化，顺序表用后插法插入元素，求...
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
【数据结构】顺序表
East-sunrise的博客
08-15 4287
顺序表带你走进数据结构世界🎈
数据结构广义表中表头与表尾的相关问题
u012159565的专栏
04-10 7074
最近在学习数据结构，用的教材是严老师的《数据结构》（C语言版），学习到广义表这节时，遇到点疑问，查资料无果，故写此博客，望大神们多多指教！     废话少说，在广义表一般记作LS = （a1, a2, ...,an），ai(1 L = (a, (b , c, d))，则GetHead(L) = a，GetTail(L) = ((b, c, d)).     假如广义表的存储方式定义如下：
顺序链表 ： 表头添加节点 + 表尾添加节点
RToax
10-12 2876
#include #include typedef struct node{ char value; struct node *next; }node, *Linklist; void main(){ Linklist list; struct node *n0 = malloc(sizeof(struct node))
顺序表的实现（头插，头删尾插，尾删）
zhaoxaun666的博客
12-18 3156
顺序表，头插，尾插，头删，头插等的实现
【数据结构】— 线性表之「顺序表」的实现
qq_63938813的博客
07-28 1137
作者：甘城なつき 文件简介：详解数据结构中线性表之顺序表的实现！！！
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
顺序表的基本操作（C语言实现）
lyzzs222的博客
10-24 1543
顺序表 **前言:**本文主要讲线性表的其中一种，那就是顺序表。顺序表就是采用顺序储存方式来存储数据。所谓顺序存储，就是数据在内存上的地址同样为连续储存，中间不允许有空（有间隔）。顺序表的优点在于支持随机访问，就是通过下标来访问元素；缺点是插入，删除数据时需要挪动大量元素。共有两种方式来创建顺序表，分别是静态顺序表和动态顺序表。 文章目录@[toc]正文开始：1.静态顺序表2.动态顺序表 正文开始： 1.静态顺序表 通过前言，我们可以了解到，顺序表中的数据是连续存放的，所以我们不难想到要用数组来建立顺序表
3.1、数据结构-线性表
最新发布
yoyo勰的博客
07-25 650
顺序列表由于元素与元素之间是相邻的，我们可以直接从首元素来查到每个元素的位置。【2021年】设有栈S和队列Q初始状态为空,数据元素序列a,b,c,d,e,f依次通过栈S,且多个元素从S出栈后立即进入队列Q,若出队的序列是b,d,f,e,c,a,则S中的元素最多时,栈底到栈顶的元素依次为()。在时间方面，由顺序表和链表的存储方式可知，当需要对元素进行破坏性操作（插入、删除）时，链表效率更高，因为其只需要修改指针指向即可，而顺序表因为地址是连续的，当删除或插入一个元素后，后面的其他节点位置都需要变动。
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殿下p

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

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

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

打赏作者

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

抵扣说明：

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

余额充值