数据结构：顺序表(C实现)

最新推荐文章于 2024-11-04 22:00:34 发布
最新推荐文章于 2024-11-04 22:00:34 发布
阅读量851 收藏 26
点赞数 34
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li209779/article/details/131955149
版权

在这里插入图片描述

个人主页 水月梦镜花
个人专栏 C语言 ，数据结构

文章目录

一、顺序表

顺序表是用一段物理结构连续的存储单元依次存储数据元素的线性结构，一般采用数组存储。
顺序表一般分为两种：

  • 静态顺序表：使用定长数组实现
  • 动态顺数表：使用动态开辟的数组实现

本篇文章，顺序表是使用动态开辟的数组实现(动态顺序表)。要实现的功能如下：

//初始化顺序表
void SeqListInit(SeqList* ps);

//销毁顺序表
void SeqListDestroty(SeqList* ps);

//打印顺序表
void SeqListPrint(SeqList* ps);

//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDateType x);

//顺序表头插
void SeqLsitPushFront(SeqList* ps, SLDateType x);

//顺序表尾删
void SeqListPopBack(SeqList* ps);

//顺序表头删
void SeqListPopFront(SeqList* ps);

//顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);

//在pos位置前插入元素
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

//检查容量
void SeqListCheckCapacity(SeqList* ps);

二、实现思路

画图理解起来更佳！！！

1.存储结构

我们重命名int类型为SLDataType，方便以后我们修改顺序表存储元素的类型。
指针data指向动态开辟的空间，变量sz记录有效的数据元素，变量capacity记录动态开辟空间的大小。

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* data;
	int sz;
	int capacity;
}SeqList;

2.初始化顺序表(SeqListInit)

动态开辟一块空间，用data指针保存空间首地址。
此时data指向空间中有效元素为0，使sz == 0，变量capacity在等于此时开辟空间的大小。

#define SIZE 4

void SeqListInit(SeqList* ps)
{
	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * SIZE);
	if (ps->data == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	ps->sz = 0;
	ps->capacity = SIZE;
}

3.销毁顺序表(SeqListDestroty)

free所开辟的空间，使data == NULL，此时数据有效元素为0，空间大小为0，那么sz = 0，capacity = 0；

//销毁顺序表
void SeqListDestroty(SeqList* ps)
{
	assert(ps);

	//free(ps);
	free(ps->data);
	ps->data = NULL;
	ps->sz = 0;
	ps->capacity = 0;
}

4.打印顺序表(SeqListPrint)

这个函数非常简单，只要遍历一遍所开辟的空间即可，注意范围是(0，sz)。

//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps);

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

}

5.顺序表尾插(SeqListPushBack)and检查容量(SeqListCheckCapacity)

每次加入数据时，我们要先检查空间大小是否充足，再加入数据

  • 检查容量
    在尾插数据前，要检查空间大小是否充足(sz == capacity)，如果空间大小不够，要扩大空间大小，capacity记录新的空间大小。

  • 尾插元素
    变量sz不仅代表空间有效元素个数，也代表了新数据元素将要放入的位置。所以尾插元素，只要空间大小充足，那么在data[sz]处放入数据即可，不要忘记sz要加一。

//检查容量
void SeqListCheckCapacity(SeqList* ps)
{
	SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * ps->capacity * 2);
	if (tmp == NULL)
	{
		perror("realloc");
		exit(-1);
	}

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



//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	ps->data[ps->sz] = x;
	ps->sz++;
}

6.顺序表头插(SeqLsitPushFront)

顺序表除了尾插，尾删不用挪到数据，其它的增删都要挪到数据。
头插数据，要先检查空间大小，再向后挪到数据，将数据放入data[0]处，sz在加一。

//顺序表头插
void SeqLsitPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	int end = ps->sz;
	while (end > 0)
	{
		ps->data[end] = ps->data[end - 1];
		end--;
	}

	ps->data[0] = x;
	ps->sz++;
}

7.顺序表尾删(SeqListPopBack)

变量sz代表有效数据的个数，那么只要sz减一，就代表最后一个数据被删除了。

//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->sz != 0);

	ps->sz--;
}

8.顺序表头删(SeqListPopFront)

头删数据，要将数据从后向前挪到，覆盖掉第一个数据，sz要减一。

//顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->sz != 0);

	for (int i = 0; i < ps->sz - 1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;
}

9.顺序表查找(SeqListFind)

遍历一遍动态开辟的数组，如果找到了就放回下标，没有就放回-1。

//顺序表查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);

	for (int i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}

	return -1;
}

10.在pos位置前插入元素(SeqListInsert)

要先检查空间容量是否充足和要插入的位置是否合法(要在顺序表的有效数据内)，再将pos下标后的数据向后挪到，将数据放入data[pos]处，sz加一。
这个函数思路简单，但要注意下面两点：

  • 如果pos == 0，不就是要在顺序表第一个元素前插入元素，不就是顺序表的头插。
  • 如果pos == sz，我们知道sz还表示下一个数据要放入的位置，那么我在下一个数据要放入的位置前插入元素，不就是顺序表的尾插。

理解这点后，我们以后的头插，尾插都可以用该函数复用。方便我们手撕顺序表

//在pos位置前插入元素
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->sz);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	int end = ps->sz;
	while (end > pos)
	{
		ps->data[end] = ps->data[end - 1];
		end--;
	}

	ps->data[pos] = x;
	ps->sz++;
}

11.删除pos位置的值(SeqListErase)

删除pos位置处的数据，先检查pos的合法性(要属于[0，sz-1])，要将数据从后向前挪到数据，sz减一。
这个函数思路简单，但要注意下面两点：

  • 如果pos == 0，不就是要删除第一个数据，不就是头删。
  • 如果pos == sz - 1，不就是要删除最后一个数据，不就是尾删。

所以对于尾删，头删函数而言，我们也可以使用该函数复用。

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->sz);

	for (int i = pos; i < ps->sz - 1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;
}

三、代码实现

头删，头插，尾删，尾插我都复用了SeqListInsert和SeqListErase。
SeqList.h 文件存放有关函数的声明以及结构体的声明
SeqList.c 文件存放函数的定义

//SeqList.h 文件

#pragma once

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

#define SIZE 4

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* data;
	int sz;
	int capacity;
}SeqList;



//初始化顺序表
void SeqListInit(SeqList* ps);

//销毁顺序表
void SeqListDestroty(SeqList* ps);

//打印顺序表
void SeqListPrint(SeqList* ps);

//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDateType x);

//顺序表头插
void SeqLsitPushFront(SeqList* ps, SLDateType x);

//顺序表尾删
void SeqListPopBack(SeqList* ps);

//顺序表头删
void SeqListPopFront(SeqList* ps);

//顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);

//在pos位置前插入元素
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

//检查容量
void SeqListCheckCapacity(SeqList* ps);

//SeqList.c 文件

#include "SeqList.h"


//初始化顺序表
void SeqListInit(SeqList* ps)
{
	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * SIZE);
	if (ps->data == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	ps->sz = 0;
	ps->capacity = SIZE;
}

//检查容量
void SeqListCheckCapacity(SeqList* ps)
{
	SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * ps->capacity * 2);
	if (tmp == NULL)
	{
		perror("realloc");
		exit(-1);
	}

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



//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	/*assert(ps);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	ps->data[ps->sz] = x;
	ps->sz++;*/

	SeqListInsert(ps, ps->sz, x);
}


//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps);

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

}


//销毁顺序表
void SeqListDestroty(SeqList* ps)
{
	assert(ps);

	//free(ps);
	free(ps->data);
	ps->data = NULL;
	ps->sz = 0;
	ps->capacity = 0;
}


//顺序表头插
void SeqLsitPushFront(SeqList* ps, SLDataType x)
{
	/*assert(ps);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	int end = ps->sz;
	while (end > 0)
	{
		ps->data[end] = ps->data[end - 1];
		end--;
	}

	ps->data[0] = x;
	ps->sz++;*/

	SeqListInsert(ps, 0, x);
}


//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	/*assert(ps);
	assert(ps->sz != 0);

	ps->sz--;*/

	SeqListErase(ps, ps->sz - 1);
}

//顺序表头删
void SeqListPopFront(SeqList* ps)
{
	/*assert(ps);
	assert(ps->sz != 0);

	for (int i = 0; i < ps->sz - 1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;*/

	SeqListErase(ps, 0);
}


//顺序表查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);

	for (int i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}

	return -1;
}


//在pos位置前插入元素
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->sz);

	if (ps->sz == ps->capacity)
	{
		SeqListCheckCapacity(ps);
	}

	int end = ps->sz;
	while (end > pos)
	{
		ps->data[end] = ps->data[end - 1];
		end--;
	}

	ps->data[pos] = x;
	ps->sz++;
}


//删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->sz);

	for (int i = pos; i < ps->sz - 1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;
}

总结

以上就是顺序表的实现。谢谢支持！！！

在这里插入图片描述

水月梦镜花
关注
专栏目录
PTA—C语言数据结构：顺序表.ppt
10-11
2. C语言实现顺序表： 在C语言中，我们可以定义一个结构体来表示顺序表，结构体中包含一个数组和数组的长度。例如： ```c typedef struct { int* data; int length; int capacity; } SeqList; ``` 这里的`...
数据结构顺序表，c语言简单实现
01-12
本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过索引直接访问任何位置的元素，其时间复杂度为O(1)。然而，插入和删除元素时，...
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
数据结构中的顺序表是一种基本的线性存储结构，它在内存中连续存放元素，通过下标访问元素。本文将深入探讨如何使用C语言实现顺序表，并重点讲解`realloc`函数在扩展内存时的作用。 首先，我们需要理解顺序表的基本...
数据结构+顺序表的C语言实现
04-24
本工程实现了严蔚敏 《数据结构 C语言》中顺序表的实现以及常用的操作。包括顺序表的初始化、销毁、求表长、查找、查询前驱节点、查询后继节点、插入、删除、遍历、打印等功能。并且写了测试代码，对每个函数都做了...
数据结构：顺序表（链式存储）
12-07
使用c实现数据结构中的顺序表（链式存储）： 功能： 1、头节点的创建 2、判断链表是否是 空\满 3、计算链表节点个数 4、插入节点（按 下标\元素） 5、删除节点（按 下标\元素） 6、按元素查询下标 7、打印链表 8、...
通用型函数——冒泡排序
2401_84654619的博客
10-29 531
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【数据结构】插入排序和希尔排序
wheeldown的博客
11-01 408
这种方法通过分组和逐步缩小增量的方式，提高了排序效率。综合来看，希尔排序的效率明显高于直接插入排序算法。重复步骤 2-4，直到 gap = 1，此时相当于直接插入排序。当gap > 1时都是预排序，⽬的是让数组更接近于有序。1.元素集合越接近有序，直接插⼊排序算法的时间效率越⾼。的了，这样就会很快。这样整体⽽⾔，可以达到优化的效果。选定一个整数（通常是 gap = n/3 + 1）。将待排序记录分成若干组，每组内记录的距离相等。缩小增量：gap = gap/3 + 1。希尔排序是对直接插⼊排序的优化。
三傻排序和对数器
jeffery 的博客
10-31 723
对数器是一种验证算法正确性的方式，可以在没有 OJ 的情况下验证。认识三个简单的排序：插入排序、选择排序、冒泡排序，并用对数器进行验证。
探索数据结构：数组与链表
qq_36287830的博客
11-04 409
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
线性数据结构之链表
m0_61840987的博客
10-31 605
单链表、双向链表、循环链表、哨兵链表在不同场景下的应用优势。每种链表类型在特定应用场景中能够发挥其独特的性能优势，通过选择合适的数据结构可以使程序更高效。
【初阶数据结构篇】链式结构二叉树（二叉链）的实现（感受递归暴力美学）
braveact的博客
11-04 1042
按照规则，⼆叉树的遍历有：前序/中序/后序的递归结构遍历：1）前序遍历(Preorder Traversal 亦称先序遍历)：访问根结点的操作发⽣在遍历其左右⼦树之前访问顺序为：根结点、左⼦树、右⼦树2）中序遍历(Inorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之中（间）访问顺序为：左⼦树、根结点、右⼦树3）后序遍历(Postorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之后访问顺序为：左⼦树、右⼦树、根结点。
【数据结构与算法】第7课—数据结构之队列
weixin_70620792的博客
10-31 500
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表栈只允许在栈顶进行插入数据删除数据的操作，称为入栈、出栈（或压栈）队列则是队尾进队头出，满足先进先出的原则，而栈则是后进先出。
第15课 算法（下）
小怪兽的博客
11-01 1124
掌握冒泡排序、选择排序、插入排序、顺序查找、对分查找的的基本原理，并能使用这些算法编写简单的Python程序。
线性数据结构之数组
m0_61840987的博客
10-31 380
数组是一种数据结构，用于存储多个相同类型的元素。在许多编程语言中，数组是最基本的数据结构之一，常用于管理和处理数据。数组的元素在内存中是连续存储的，可以通过索引直接访问。
数据结构-快速排序
2302_80490510的博客
11-04 141
快速排序法介绍:快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序时间复杂度：O(N*logN)空间复杂度：O(logN)稳定性：不稳定。
数据结构和算法-01背包问题01-认识01背包
qq_36115196的博客
10-31 302
0-1背包问题： 介绍0-1背包的两种实现方式， 回溯法和动态规划法。
数据结构---排序（上）
最新发布
深夜敲代码
11-04 253
思想：将一个个未排序的数字插入到已经排好顺序的数组中。例如：思路：先将前两个数字排序，然后将后面数字与前面数字比较排序。操作：1.引入变量 i 遍历数组[1，array.lenth]2.用临时变量tmp记录[i]的值，用于后续比较。3.与前面数字比较，用 j 遍历[0，i-1]4.判断[j]与tmp大小，若[j]>tmp则令[j]5.将tmp放在[j+1]时间复杂度：O（n*n）空间复杂度：O（1）稳定性：稳定适用范围：数组越有序，排序越快。
Redis-数据结构和内部编码
ketil27的博客
11-04 371
type 命令实际返回的就是当前键的数据结构类型，它们分别是：string（字符串）、list（列 表）、hash（哈希）、set（集合）、zset（有序集合），但这些只是Redis对外的数据结构。实际上Redis针对每种数据结构都有⾃⼰的底层内部编码实现，⽽且是多种实现，这样Redis会 在合适的场景选择合适的内部编码，如表2-1所⽰。可以看到每种数据结构都有⾄少两种以上的内部编码实现，例如list数据结构包含了linkedlist和 ziplist 两种内部编码。
数据结构之线段树
zaishaoyi的专栏
11-01 284
的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。线段树是算法竞赛中常用的用来维护。
C语言实现数据结构：顺序表与链表操作
"本次实验是数据结构与算法课程的一部分，主要关注C语言中数据结构的实现，特别是顺序表和链表。学生陈*文在2024年3月31日在实验室B101进行了实验，实验内容包括顺序表和链表的基本操作，如创建、销毁、获取长度、...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

水月梦镜花

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

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

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

打赏作者

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

抵扣说明：

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

余额充值