[简单易懂]数据结构顺序表——C语言

最新推荐文章于 2024-08-25 11:51:22 发布
最新推荐文章于 2024-08-25 11:51:22 发布
阅读量1.1k 收藏 5
点赞数 20
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63816268/article/details/123562050
版权
本文详细介绍了顺序表的概念及其作为线性表的特性，重点讲解了如何使用C语言实现顺序表的动态内存管理、初始化、打印、扩容、尾插尾删、头插头删、插入删除、查找和修改等功能。通过具体代码示例展示了每个操作的过程，包括在结构体定义、内存分配、扩容策略等方面的关键细节。
摘要由CSDN通过智能技术生成

前言💖：

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

为什么要学习顺序表？

1.连续的物理空间，方便下标随机访问（查找访问）
2.支持排序，二分查找

车站🚗：

代码注释

结构体定义

初始化和打印函数

扩容函数

尾插尾删

头插头删

随机插，删

查和改

清空

最终代码

注释👀：

制作顺序表需要的功能有：增删查改

我们创建两个.c文件，一个.h文件分别实现菜单(test.c)，具体代码(SeqList.c)，函数声明和头文件(SeqList.h)

实现功能的代码注释：

void SeqListPrint(SeqList* psl); //打印
void SeqListInit(SeqList* psl); //初始化
void SeqListDestroy(SeqList* psl); //清空
void SeqListCheckCapacity(SeqList* psl); //扩容
void SeqListPushBack(SeqList* psl, SLDataType x); //尾加
void SeqListPopBack(SeqList* psl); //尾删
void SeqListPushFront(SeqList* psl, SLDataType x); //头插
void SeqListPopFront(SeqList* psl); //头删
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x); //在pos位置插入
void SeqListErase(SeqList* psl, size_t pos); //删除pos位置的数据
int SeqListFind(SeqList* psl, SLDataType x); //查找
void SeqListModify(SeqList* psl, size_t pos, SLDataType x); //修改

过程🙌：

1.顺序表结构体的定义：

//重定义int和链表名字，增加可读性和维护性
typedef int SLDataType;
typedef struct SeqList {
	SLDataType* a;
	int size; //存储数据的个数
	int capacity; //存数据的大小(扩容大小)
}SeqList;

2.定义完成后，在菜单文件进行结构体命名，再实现初始化和打印函数

//test.c
SeqList s;
SeqListInit(&s); //传入结构体s的地址

//SeqList.h
void SeqListInit(SeqList* psl); //用*psl接收s
void SeqListPrint(SeqList* psl);

//SeqList.c
void SeqListInit(SeqList* psl)
{
	assert(psl); //断言psl不为空
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}
void SeqListPrint(SeqList* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

3.在初始化完成后，我们需要思考一个问题，就是在进行增删查改时，a数组的空间该如何分配，如果用宏定义a的空间，那并不好控制空间的动态大小，所以我们实现一个动态内存分配的函数，当我们需要扩容时只需要调用函数即可

//SeqList.h
void SeqListCheckCapacity(SeqList* psl); //扩容

//SeqList.c
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);
	if (psl->size == psl->capacity) //当已有大小等于扩容大小时
	{
		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2; //从4开始扩容，之后每扩一次都是两倍扩
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity); //用*tmp接收扩容后的值
		if (tmp == NULL) //当已经无法扩容时退出程序
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = newCapacity;
		}
	}
}

4.完成了扩容函数，现在就可以开始实现插入删除了，我们先完成尾插尾删的函数

//test.c
SeqListPopBack(&s);//尾删
SeqListPushBack(&s, x); //尾插x

//SeqList.h
void SeqListPopBack(SeqList* psl);
void SeqListPushBack(SeqList* psl, SLDataType x);

//SeqList.c
void SeqListPopBack(SeqList* psl)
{
    assert(psl);
    if(psl->size > 0)
    {
        psl->size--;
    }
}
void SeqListPushBack(SeqList* psl, SLDataType x)
{
    assert(psl->a);
    SeqListCheckCapacity(psl); //防止内存不够先进行扩容
    psl->a[psl->size] = x; //原本最后一位下标为size-1，插入一个元素为size
    psl->size++; //size个数+1
}

5.之后是头插头删函数

//test.c
SeqListPopFront(&s, x); //在头部插入x
SeqListPushFront(&s);

//SeqList.h
void SeqListPushFront(SeqList*psl，SLDataType x);
void SeqListPopFront(SeqList*psl);

//SeqList.c
void SeqListPushFront(SeqList* psl, SLDataType x)
{
    assert(psl);
    SeqListCheckCapacity(psl); //老样子，先扩容
    int end = psl->size - 1;
    while(end >= 0)
    {
        psl->a[end + 1] = psl->a[end]; //让元素依次往后移
        --end;
    }
    psl->a[0] = x; //在覆盖完成后，x的值就可以赋给第一个元素了
    psl->size++;
}
void SeqListPopFront(SeqList*psl)
{
    assert(psl);
    if(psl->size > 0) //防止size为负
    {
        int begin = 1; //定义下标begin，从第二个元素开始
        while(begin < psl->size) //当begin没有超过size时便会一直覆盖
        {
            psl->a[begin - 1] = psl->a[begin]; //让元素依次往前移
            begin++;
        }
        --psl->size; //size个数-1
    }
}

6.查找位置删除和查找位置之后插入

//test.c
SeqListInsert(&s, pos, x);//在pos位置之前插入x
SeqListInsert(&s, pos); //在pos位置删除

//SeqList.h
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
void SeqListErase(SeqList* psl, size_t pos);

//SeqList.c
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size); //防止查找的pos越界
	SeqListCheckCapacity(psl); //扩容
	size_t end = psl->size; //end为最后一个元素的下标
	while (end > pos)
	{
		psl->a[end] = psl->a[end - 1]; //从后往前移动元素，直到遇到pos位置时停下，相当于将pos位置之前的位置进行前移
		--end;
	}
	psl->a[pos] = x;
	psl->size++;
}
void SeqListErase(SeqList* psl, size_t pos)
{
    assert(psl);
    assert(pos < psl->size);
    size_t begin = pos + 1;
    while(begin < psl->size)
    {
        psl->a[begin - 1] = psl->a[begin]; //从后往前移动
        begin++;
    }   
    psl->size--;
}

7.目前为止，我们的增和删就已经完成了，接下来的查和改就很简单了

//test.c
SeqListFind(&s, x);
SeqListModify(&s, pos, x); //将pos位置改为x

//SeqList.h
int SeqListFind(SeqList* psl, SLDataType x);
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);

//SeqList.c
int SeqListFind(SeqList* psl, SLDataType x)
{
    assert(psl);
	for (int i = 0; i < psl->size; ++i)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
    assert(psl);
    assert(pos < psl->size);
    psl->a[pos] = x;
}

8.最后，实现一个清空顺序表的函数

//test.c
SeqListDestroy(&s);

//SeqList.h
void SeqListDestroy(SeqList* psl);

//SeqList.c
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a); //注意：释放后的指针为野指针，我们还需要将其置空
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

最终代码

test.c部分


#include "SeqList.h"
int main()
{
	SeqList s;
	SeqListInit(&s); //传入结构体s的地址
	SeqListPushFront(&s, 13);//头插
	SeqListPushFront(&s, 12);
	SeqListPushFront(&s, 11);
	SeqListPushFront(&s, 10);

	SeqListPushBack(&s, 19);//尾插
	SeqListPushBack(&s, 20);
	SeqListPushBack(&s, 21);
	SeqListPushBack(&s, 22);

	SeqListInsert(&s, 3, 100);//在第三个元素后插入100
	SeqListPrint(&s);
	SeqListErase(&s, 3);//删除第三个元素
	SeqListPopFront(&s); //头删
	SeqListPopBack(&s); //尾删
	SeqListPrint(&s);
	int num = SeqListFind(&s, 11); //查找值为11的下标
	printf("下标为:%d\n", num); //打印值为11的下标
	SeqListModify(&s, 3, 200); //修改pos之后的值
	SeqListPrint(&s);
	SeqListDestroy(&s);
}

SeqList.h部分

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
typedef struct SeqList {
	SLDataType* a;
	int size; //存储数据的个数
	int capacity; //存数据的大小(扩容大小)
}SeqList;
void SeqListPrint(SeqList* psl); //打印
void SeqListInit(SeqList* psl); //初始化
void SeqListDestroy(SeqList* psl); //清空
void SeqListCheckCapacity(SeqList* psl); //扩容
void SeqListPushBack(SeqList* psl, SLDataType x); //尾加
void SeqListPopBack(SeqList* psl); //尾删
void SeqListPushFront(SeqList* psl, SLDataType x); //头插
void SeqListPopFront(SeqList* psl); //头删
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x); //在pos位置插入
void SeqListErase(SeqList* psl, size_t pos); //删除pos位置的数据
int SeqListFind(SeqList* psl, SLDataType x); //查找
void SeqListModify(SeqList* psl, size_t pos, SLDataType x); //修改

SeqList.c部分

#include "SeqList.h"
void SeqListInit(SeqList* psl)
{
	assert(psl); //断言psl不为空
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}
void SeqListPrint(SeqList* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);
	if (psl->size == psl->capacity) //当已有大小等于扩容大小时
	{
		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2; //从4开始扩容，之后每扩一次都是两倍扩
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity); //用*tmp接收扩容后的值
		if (tmp == NULL) //当已经无法扩容时退出程序
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = newCapacity;
		}
	}
}
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		psl->size--;
	}
}
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl->a);
	SeqListCheckCapacity(psl); //防止内存不够先进行扩容
	psl->a[psl->size] = x; //原本最后一位下标为size-1，插入一个元素为size
	psl->size++; //size个数+1
}
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl); //老样子，先扩容
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end]; //让元素依次往后移
		--end;
	}
	psl->a[0] = x; //在覆盖完成后，x的值就可以赋给第一个元素了
	psl->size++;
}
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0) //防止size为负
	{
		int begin = 1; //定义下标begin，从第二个元素开始
		while (begin < psl->size) //当begin没有超过size时便会一直覆盖
		{
			psl->a[begin - 1] = psl->a[begin]; //让元素依次往前移
			begin++;
		}
		--psl->size; //size个数-1
	}
}
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size); //防止查找的pos越界
	SeqListCheckCapacity(psl); //扩容
	size_t end = psl->size; //end为最后一个元素的下标
	while (end > pos)
	{
		psl->a[end] = psl->a[end - 1]; //从后往前移动元素，直到遇到pos位置时停下，相当于将pos位置之前的位置进行前移
		--end;
	}
	psl->a[pos] = x;
	psl->size++;
}
void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl);
	assert(pos < psl->size);
	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin]; //从后往前移动
		begin++;
	}
	psl->size--;
}
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	for (int i = 0; i < psl->size; ++i)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size);
	psl->a[pos] = x;
}
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a); //注意：释放后的指针为野指针，我们还需要将其置空
	psl->a = NULL;
	psl->capacity = psl->size = 0;
	printf("释放完成！\n");
}
数据结构——顺序表（C语言）
Melody_my的博客
10-03 417
数据结构——顺序表基本操作（C语言） 1.初始化 2.创建 3.插入 4.删除 5.按值查找 6.打印 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 10010 #define ElemType int typedef struct { ElemType data[MAXSIZE]; int length; }SeqList; //顺序表初始化 bool InitList(SeqList *l){
C语言数据结构-顺序表
qq_40738945的博客
12-25 442
总提 1.集合结构 2.线性结构特点：除了头尾，中间的每一个节点都存在一个前区和后继且没有空存在。 3.树形结构特点：一对多，多个后继一个前区 4.图特点：多对多 数据结构将现实的结构进行了数据结构化，基本就只有这四种关系 我们画在图纸上的结构称之为逻辑结构，将结构存放于内存中被称之为物理结构。当逻辑结构和物理结构接近时更容易代码实现，也更容易理解。 线性表 ...
数据结构之顺序表(C语言实现)
Infinitewu的博客
08-25 707
本文介绍了顺序表的概念，以及动态顺序表的c语言实现
c语言数据结构顺序表
m0_51579489的博客
04-09 388
#include<stdio.h> #define maxsize 50 typedef int elemtype; typedef struct { elemtype data[maxsize]; int len; }lqlist; bool initlist(lqlist& l, elemtype n) { if (n<1 || n>maxsize) { return false; } printf("请...
数据结构之顺序表（C语言）
weixin_50803498的博客
10-14 2891
线性表、顺序表、线性表存储结构、顺序表初始化、顺序表数据插入、顺序表数据删除、按位插入、按位删除、顺序表的使用场景、适合场景、不适合场景
数据结构（C语言版）顺序表
搬砖者也
05-28 3004
线性表及其顺序存储2.1线性表线性表是一个线性结构它是一个n&gt;=0各结点的有限序列，对于其中的结点，有且仅有一个开始结点，它没有前驱但有一个后继结点；有且仅有一个终端结点，它没有后继只有前驱；其他结点有且仅有一个 前驱和一个后继结点。线性表在计算机中的存储基本上是采用顺序存储和链式存储两种方式。2.2顺序表线性表采用顺序存储的方式就是顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构—刘小晶—例2.7——用顺序表结构写的学生成绩管理系统
07-18
总之，这个例子展示了如何将理论上的数据结构知识应用到实际问题中，通过顺序表实现一个简单的学生成绩管理系统。这不仅是对数据结构概念的巩固，也是对编程技巧和问题解决能力的锻炼。理解并掌握这样的实例有助于...
深入剖析无头单链表——C语言动图演示
一些七零八碎的知识点
03-14 3391
深度剖析单链表——C语言实现。简单易懂，源码附上
《数据结构——用C语言描述》第一章 基础概念与习题
CSDNChinaLUCKY的博客
03-28 1637
《数据结构——用C语言描述》第一章 基础概念与习题
《数据结构C语言版》严蔚敏——拓扑排序算法解析
书中通过C语言实现，提供了直观易懂的代码示例，帮助读者理解数据结构的原理和实际应用。 拓扑排序是图论中的一个重要概念，特别是在有向无环图(DAG, Directed Acyclic Graph)中。在描述的拓扑排序过程中，我们看到...
数据结构_顺序表(C语言)
小黯
08-07 1957
目录顺序表的基本操作创建顺序表初始化顺序表销毁顺序表置空顺序表判断顺序表是否为空取顺序表第i个数据元素查找顺序表某数据位置将某数据插入顺序表删除顺序表中某数据遍历顺序表单链表 顺序表的基本操作 创建顺序表 初始化顺序表 销毁顺序表 置空顺序表 判断顺序表是否为空 取顺序表第i个数据元素 查找顺序表某数据位置 将某数据插入顺序表 删除顺序表中某数据 遍历顺序表 单链表 ...
数据结构之顺序表（C语言版）
qq_59343045的博客
07-16 3183
静态顺序表的部分简单操作
【C语言】--数据结构--顺序表
weixin_64609308的博客
05-13 1002
此博客会涉及顺序表的概念以及顺序表的模拟
数据结构顺序表（C语言实现)
qq_61939403的博客
03-17 2207
文章目录：线性表顺序表顺序表接口实现1.顺序表初始化顺序表空间增容 线性表 线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、栈、队列、字符串等。 线性表在逻辑上是线性结构，也就是连续的一条直线。但在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式的形式存储。 顺序表 顺序表是用一段物理连续地址的存储单元依次存储数据元素的线性结构，一般情况采用数组存储。在数组上面完成数据的增删查改。 一般情况下，
数据结构顺序表c语言
qq_42764860的博客
04-18 343
#include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef int ElemType; typedef struct{ ElemType elem[MaxSize]; int length; }SqList;//定义顺序表结构体 void InitList(SqList &L) {L=(SqL...
数据结构 ——顺序表【c语言版】
clear-ninghongkang的博客
11-19 6198
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的顺序存储结构———顺序表 顺序存储结构——逻辑上相邻的元素，在物理上也相邻 在c语言中，顺序表通常用数组来存储，这与python中的列表不同，数组是给定长度的，数组中元素的地址也是相邻的，且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的，(因为pyt...
用C语言实现数据结构顺序表的排列
最新发布
09-11
在C语言中，我们可以使用数组来实现基本的顺序表数据结构，然后使用选择排序、冒泡排序或快速排序等算法来进行元素的排列。这里以冒泡排序为例，因为其简单易懂： 首先，我们需要定义一个顺序表的结构体，包含一个指向数据的指针数组和长度信息： ```c typedef struct { int* data; // 存储数据的数组 int size; // 数组长度 } SequenceList; ``` 接下来，创建顺序表并初始化： ```c SequenceList list = { .data = malloc(sizeof(int) * MAX_SIZE), .size = 0 }; ``` 现在我们来实现冒泡排序： ```c void bubbleSort(SequenceList* list) { int i, j, temp; for (i = 0; i < list->size - 1; i++) { for (j = 0; j < list->size - i - 1; j++) { if (list->data[j] > list->data[j + 1]) { temp = list->data[j]; list->data[j] = list->data[j + 1]; list->data[j + 1] = temp; } } } } ``` 最后，为了展示已排序的顺序表，你可以遍历并打印数组： ```c void printList(SequenceList* list) { for (int i = 0; i < list->size; i++) { printf("%d ", list->data[i]); } printf("\n"); } ``` 完整例子： ```c // 初始化和添加元素到顺序表... // ... bubbleSort(&list); // 排序 printList(&list); // 打印排序后的顺序表 ```
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

A.A呐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值