数据结构顺序表的初始化，头插，尾插，头删，尾删，指定位置删除，指定位置插入，查找，销毁（详解）

最新推荐文章于 2024-07-01 22:13:40 发布
最新推荐文章于 2024-07-01 22:13:40 发布
阅读量581 收藏 12
点赞数 13
分类专栏： c语言 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79722622/article/details/137384237
版权

目录

前言

数据结构是什么？
数据结构是两个词的集合
数据：是一系列的在杂乱无章的数据的集合
结构：是有条理，清晰的集合（例如目录）
数据结构就是一些有条理数据的集合
数据结构是计算机存储和组织数据的方式

顺序表的介绍

顺序表是线性表的一种
那么顺序表和线性表到底是什么呢？

线性表：具有相同特性的数据结构的集合
例如：蔬菜：黄瓜，白菜，莲藕
相同特性：蔬菜
顺序表的底层是数组，但是在数组的基础上有增删查改等方法，就变成了数据结构

线性表有物理结构和逻辑结构

线性表：
物理结构：不一定是连续的
逻辑结构：一定是连续的

物理结构：例如数组的下标一定是连续的
在这里插入图片描述

逻辑结构：例如商店门口排队的人，人排队的位置不一定是一条直线，但是在逻辑上是一条直线
在这里插入图片描述

顺序表的物理结构一定是连续的，
逻辑结构也一定是连续的
因为顺序表的底层是数组，数组的物理结构和逻辑结构一定是连续的

顺序表需要的基础有：
动态内存管理
指针
结构体

写顺序表先创建三个文件
一个测试文件（.c）:测试顺序表的方法
一个顺序表的头文件（.h）：顺序表的结构，声明顺序表的方法
一个顺序表的源文件（.c）：实现顺序表的方法

静态顺序表

#define N 100
//100可以用N代替，后续可以方便修改数据

struct SeqList
{
   int arr[N];//定长的数组
   int size；//顺序表当前有效的数据个数
};

数组给大了，空间浪费
数组给小了，空间不够
静态顺序表的缺点还是比较多的

动态顺序表

struct SeqList
{
  int* arr;//指向顺序表的指针
  int size;//顺序表中有效数据个数
  int capacity;//顺序表的空间大小
};

动态顺序表可以动态增加顺序表的大小（动态增容）
防止了空间的大量浪费
也防止了空间的不足
所以下面我们来实现动态顺序表

一.顺序表的初始化

//SeqList.c
#include"SeqList.h"

//初始化顺序表
void SLInit(SL* ps)
{
	ps->arr = NULL;//将数组置为NULL
	ps->size = 0;//有效数据为0
	ps->capacity = 0;//空间大小为0
}

二.销毁

//SeqList.c
//销毁顺序表
void SLDestroy(SL* ps)
{
	//如果顺序表不为空，说明arr中还有动态申请的空间
	//要把动态申请的空间free掉
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	//顺序表不用了，置为NULL
	ps->size = ps->capacity = 0;
	//销毁完有效元素和空间为0
}

扩容顺序表

后面需要使用到，所以提前说
在这里插入图片描述

所以要用realloc增容，而不是malloc

//二倍或三倍地扩容
//扩容顺序表
void SLCheck(SL* ps)
{
	assert(ps);
	if(ps->capacity == ps->size)
	//看看空间够不够
	{
		//三目操作符判断给4个空间，还是直接增容2倍
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
		DataType* tmp = realloc(ps->arr, sizeof(DataType) * NewCapacity);
		//用新的指针接收，防止增容失败
		if (tmp == NULL)
		{
			perror("realloc");
			return;//增容失败，提前返回
		}
		//增容成功
		ps->arr = tmp;
		ps->capacity = NewCapacity;
	}
}

打印顺序表

//打印顺序表
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
	//打印一行就换行
}

三.头插

在这里插入图片描述

//头插
void SLPushFront(SL* ps,DataType x)
{
	assert(ps);
	SLCheck(ps);
	//增容
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i-1];
		//最后一次: = 1 ,arr[1] = arr[0]
	}
	ps->arr[0] = x;
	// 0下标的位置，放入插入的元素
	(ps->size)++;
	//插入一个数据，有效元素加一
}

四.尾插

在这里插入图片描述

//尾插
void SLPushBack(SL* ps,DataType x)
{
	assert(ps);
	SLCheck(ps);
    //判断空间够不够
	ps->arr[ps->size] = x;
	// == arr[size] = x
	(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];
		// arr[size-2] = arr[size-1]
	}
	(ps->size)--;
	//删除一个元素，有效元素少一个
}

六.尾删

在这里插入图片描述

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	//指向顺序表的指针不能为空指针
	//为NULL，停止运行
	//不为NULL，继续运行
	assert(ps->size);
	//顺序表不能为空
	(ps->size)--;
	//删除一个元素，有效元素少一个
}

七.指定位置之前（包括指定位置）的插入

在这里插入图片描述

//指定位置之前插入元素
//pop:下标
//x:要插入的元素
void SLInsert(SL* ps, int pop, DataType x)
{
	assert(ps);
	assert(pop >= 0 && pop <= ps->size);
	// pop == size就是尾插
	// pop < size 在中间插入
	// pop == 0 头插
	SLCheck(ps);
	for (int i = ps->size; i > pop; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
		// arr[pop+1] = arr[pop]
	}
	ps->arr[pop] = x;
	(ps->size)++;
}

八.指定位置数据的删除

在这里插入图片描述

//指定位置之前的删除
void SLEarse(SL* ps, int pop)
{
	assert(ps);
	assert(pop >= 0 && pop < ps->size);
	
	for(int i = pop;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i+1];
		//arr[size-2] = arr[size-1]
	}
	(ps->size)--;
	//删除一个元素，有效元素减一
}

九.查找

//查找
int SLCheck1(SL* ps, DataType x)
// x是要找的数据
{
	assert(ps);
	assert(ps->size > 0);
	//至少有一个元素才能够查找

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
			//找到了，返回下标
		}
	}
	return -1;
}

全部的代码实现

// test.c文件

#define _CRT_SECURE_NO_WARNINGS

#include"SeqList.h"

void SLtest()
{
	SL sl;
	SLInit(&sl);//传址调用
	//不能使用传值调用，因为这里sl并没有值
	//传址调用，改变指针指向的内容，给指向内容初始化
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPrint(sl);//2 1
	//SLPushBack(&sl, 12);
	//SLPopFront(&sl);
	//SLPopBack(&sl);
	//SLInsert(&sl, 2, 10);
	//SLEarse(&sl, 1);
	int find = SLCheck1(&sl, 2);
	if (find < 0)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是:%d\n", find);
	}
	SLPrint(sl);
	SLDestroy(&sl);
}
int main()
{
	SLtest();

	return 0;
}

// SeqList.h文件

#pragma once

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

typedef int DataType;//顺序表可以使用多种数据类型

typedef struct SeqList
{
	DataType* arr;
	int size;//有效数据
	int capacity;//空间大小
}SL;//将struct SeqList 改名为SL，更为方便简洁

void SLInit(SL* p);//初始化

void SLDestroy(SL* sl);//销毁

void SLPushFront(SL* sl,DataType x);//头插

void SLPrint(SL sl);//打印顺序表

void SLPushBack(SL* sl, DataType x);//尾插

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

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

void SLInsert(SL* sl,int pop,DataType x);//指定位置之前的插入

void SLEarse(SL* sl, int pop);//指定位置之前的删除

int SLCheck1(SL* sl, DataType x);//查找

// SeqList.c文件


#define _CRT_SECURE_NO_WARNINGS

#include"SeqList.h"

//初始化顺序表
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;//有效数据为0
	ps->capacity = 0;//空间大小为0
}

//销毁顺序表
void SLDestroy(SL* ps)
{
	//如果顺序表不为空，说明arr中还有动态申请的空间
	//要把动态申请的空间free掉
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	//顺序表不用了，置为NULL
	ps->size = ps->capacity = 0;
	//销毁完有效元素和空间为0
}

//二倍或三倍地扩容
//扩容顺序表
void SLCheck(SL* ps)
{
	assert(ps);
	if(ps->capacity == ps->size)
	//看看空间够不够
	{
		//三目操作符判断给4个空间，还是直接增容2倍
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
		DataType* tmp = realloc(ps->arr, sizeof(DataType) * NewCapacity);
		//用新的指针接收，防止增容失败
		if (tmp == NULL)
		{
			perror("realloc");
			return;//增容失败，提前返回
		}
		//增容成功
		ps->arr = tmp;
		ps->capacity = NewCapacity;
	}
}
//头插
void SLPushFront(SL* ps,DataType x)
{
	assert(ps);
	SLCheck(ps);
	//增容
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i-1];
		//最后一次: = 1 ,arr[1] = arr[0]
	}
	ps->arr[0] = x;
	// 0下标的位置，放入插入的元素
	(ps->size)++;
	//插入一个数据，有效元素加一
}

//打印顺序表
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

//尾插
void SLPushBack(SL* ps,DataType x)
{
	assert(ps);
	SLCheck(ps);
    //判断空间够不够
	ps->arr[ps->size] = x;
	// == arr[size] = x
	(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];
		// arr[size-2] = arr[size-1]
	}
	(ps->size)--;
	//删除一个元素，有效元素少一个
}

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	//指向顺序表的指针不能为空指针
	//为NULL，停止运行
	//不为NULL，继续运行
	assert(ps->size);
	//顺序表不能为空
	(ps->size)--;
	//删除一个元素，有效元素少一个
}

//指定位置之前插入元素
//pop:下标
//x:要插入的元素
void SLInsert(SL* ps, int pop, DataType x)
{
	assert(ps);
	assert(pop >= 0 && pop <= ps->size);
	// pop == size就是尾插
	// pop < size 在中间插入
	// pop == 0 头插
	SLCheck(ps);
	for (int i = ps->size; i > pop; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
		// arr[pop+1] = arr[pop]
	}
	ps->arr[pop] = x;
	(ps->size)++;
}

//指定位置之前的删除
void SLEarse(SL* ps, int pop)
{
	assert(ps);
	assert(pop >= 0 && pop < ps->size);
	
	for(int i = pop;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i+1];
		//arr[size-2] = arr[size-1]
	}
	(ps->size)--;
	//删除一个元素，有效元素减一
}

//查找
int SLCheck1(SL* ps, DataType x)
{
	assert(ps);
	assert(ps->size > 0);
	//至少有一个元素才能够查找

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
			//找到了，返回下标
		}
	}
	return -1;
}

总结

总的来说顺序表的实现还是比较简单的
主要难的地方就是扩容，for循环的结束条件要想一下

_extraordinary_
关注
  • 13
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表的相关操作 头插，尾插，头删，尾删，任意位置插入删除
weixin_43962381的博客
12-08 2307
顺序表的相关操作 头插，尾插，头删，尾删，任意位置插入删除 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> #include<stdlib.h> typedef int slDatatype;//顺序表内的数据类型（便于维护） //动态顺序表 typedef struct seqList { slDatatype *data; //数组指针 int size;
数据结构与算法链式线性表.docx
01-10
* 按值查找—根据指定数据获取该数据所在的位置（地址）：从链表的头指针出发，顺着链域 next 逐个节点往下搜索，直至搜索到指定数据的节点为止。 * 插入—在第 i 个结点插入值为 e 的新结点：将新结点插入到第 i 个...
顺序表及其初始化、头插、头删、尾插、尾删、在指定位置插入和删除元素、查找、扩容等操作
weixin_46153828的博客
02-24 1201
首先记录一下线性表的概念： 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺
顺序表的实现(头插、尾插、头删、尾删、查找、删除、插入)
走在努力路上的自己的博客
12-25 1694
什么是数据结构​？数据结构是由“数据”和“结构”两词组合而来。什么是数据？常见的数值1、2、3、4.....、教务系统里保存的用户信息（姓名、性别、年龄、学历等等）、网页里肉眼可以看到的信息（文字、图片、视频等等），这些都是数据什么是结构？当我们想要使用大量使用同一类型的数据时，通过手动定义大量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将大量的数据组织在一起，结构也可以理解为组织数据的方式。概念：数据结构是计算机存储、组织数据的方式。
C语言动态顺序表结构的创建、初始化结构、尾插、尾删、头插、头删、指定位置插入、指定位置删除、找指定数值下标等的介绍
Farewell_me的博客
05-20 605
C语言动态顺序表结构的创建、初始化结构、尾插、尾删、头插、头删等的介绍C语言动态顺序表结构的创建、初始化结构、尾插、尾删、头插、头删等的介绍。
数据结构--线性表--思维导图.pdf
08-29
单链表的基本操作包括头插法建立、尾插法建立、按序号查找、按值查找、插入结点、删除节点等。 链表的优缺点： 链表的优点是插入和删除操作的时间复杂度为O(1)，但是需要大量的指针操作，占用额外的内存空间。链表...
数据结构编程题汇总1
08-08
27. **建立顺序表**：初始化数组并填充元素，时间复杂度为O(n)。 28. **顺序栈的入栈、出栈算法**：顺序栈的入栈是数组尾部添加，出栈是数组头部移除，时间复杂度均为O(1)。 29. **查找特定值的元素**：同26题，但...
Lesson3--顺序表_链表.pdf
10-06
动态顺序表的实现主要包括初始化、销毁、打印、检查空间、尾插、尾删、头插、头删、查找等接口。 2.3 数组相关面试题 数组相关面试题有原地移除数组中所有的元素val、删除排序数组中的重复项、合并两个有序数组、...
数据结构 严蔚敏 代码
03-14
范例1-94 顺序表的查找 273 ∷相关函数：Search_Seq函数 1.6.2 静态树表的查找 276 范例1-95 静态树表的查找 276 ∷相关函数：Search_SOSTree函数 1.6.3 二叉排序树的基本操作 280 范例1-96 二叉排序树的基本操作 ...
数据结构 - C/C++ - 栈
最新发布
0xCC说逆向
07-01 159
栈底 - 表中不允许插入、删除的一端称为栈底(bottom)，栈底位置通常是固定不变的。栈顶 - 表中允许插入、删除的一端称为栈顶(top)，栈顶位置是可以发生变化的。栈(stack)是线性表的一种形式，限定仅在表的一端进行插入或者删除的操作。LIFO - last in first out - 先进后出、后进先出。顺序栈使用连续的内存空间来存储元素，通常使用数组来实现。栈底指向数组起始地址(下标为0的元素)。栈顶指向当前栈中最后一个压入的元素位置。插入 - 进栈、入栈、压栈。
【数据结构 - 时间复杂度和空间复杂度】
2302_80393814的博客
06-29 344
一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
6-24 数据结构考题 - 顺序查找
Virgo_616的博客
07-01 99
6-24 数据结构考题 - 顺序查找
数据结构之二叉树概念
my_air的博客
07-01 472
主要解释二叉树，B-树的概念
6-25 数据结构考题 - 折半查找
Virgo_616的博客
07-01 54
6-25 数据结构考题 - 折半查找
数据结构和顺序表
2302_79180171的博客
07-01 164
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列。其中唯一的第一个数据元素称为表头元素唯一的最后一个元素称为表尾元素，除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。
【数据结构 - 二叉树】
2302_80393814的博客
06-30 795
在计算机科学中，二叉树是一种重要的数据结构，它由节点（node）组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的设计灵活性使其在各种应用中都有广泛的用途。通过本文，我们全面介绍了二叉树的基本概念、分类、基本操作和实际应用。二叉树作为一种核心数据结构，不仅在理论计算机科学中占有重要地位，而且在实际应用中有广泛的运用。深入理解二叉树将有助于提升编程能力和解决实际问题的能力。
【408考点之数据结构】顺序查找和折半查找
gygkhd的博客
07-01 341
顺序查找（Sequential Search），也称线性查找，是一种最简单、最直接的查找方法。它从数据集的第一个元素开始，逐个检查每个元素，直到找到目标元素或检查完整个数据集。
专业课代码稿1
08-03
"该资源是关于数据结构中顺序表和链表的概念以及头插法和尾插法的实现。此外，还提及了栈和队列的简单定义。" 顺序表和链表是数据结构中的基本概念，它们是存储和组织数据的两种主要方式。 顺序表是一种线性表，其...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值