C语言实现数据结构之——顺序表

于 2024-10-02 12:28:36 发布
阅读量523 收藏 11
点赞数 22
文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/favour_you___/article/details/142676714
版权

顺序表的实现与应用

一、顺序表的基本概念与特性

  顺序表是一种逻辑上和物理上均为线性的数据结构，它的底层是用数组实现的，在这篇文章中  
我们将使用C语言将顺序表的所有的功能实现出来，需要具备的知识有：结构体、动态内存管理  
以及指针相关的知识。

二、顺序表的实现

使用结构体来定义一个顺序表SL

typedef int SLDatatype
typedef struct SeqList
{
	SLDatatype* arr;
	int size;  
	int capacity;
}SL;

这里注意我们定义的是动态顺序表，也就是大小并没有确定下来的，并且可以改变的顺序表，与之对应的有静态顺序表，也就是大小在编译的时候就已经确定下来的。因为我们可能之后要在数组里面放char类型的变量，因此不能仅仅写int，我们选择用SLDatatype来代替，一遍一键替换。
在这个结构体中我们定义了三个参数：第一个是一个指针arr，指向的是一个数组，数组里的每一个值的类型都是SLDatatype;第二个是size,表示的是arr的数组里面的元素的个数；第三个是capacity，指的是arr数组的容量大小，也就是arr数组的开辟的空间字节数。

三、顺序表的操作以及实现

顺序表的操作主要有：顺序表的初始化；顺序表的销毁；顺序表的打印；顺序表的插入数据操作；检查顺序表的容量；顺序表的删除数据操作（头删和尾删）；在指定的位置钱插入数据；删除指定位置的数据；找到指定的元素
首先我们先建立一个项目，然后再建立一个头文件SeqList.h用来声明我们要用到的方法，再建立一个源文件SeqList.c用来实现具体的操作，再建立一个源文件test.c用来测试我们的代码

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int SLDatatype;

typedef struct SeqList
{
  SLDatatype* arr;
  int capacity;
  int size;
}SL;
void SLInit(SL* ps);

1、下面我们来实现顺序表的初始化方法，在刚开始的时候，我们将arr指向空指针，然后因为里面并不存放数据，因此我们将其中的size和capacity全部设置为0

#include "SeqList.h"
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

2、接下来是动态顺序表的销毁操作，我们知道arr后面指向的空间是要动态开辟的，因此需要我们手动的去销毁

void SLDestroy(SL* ps);

void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);  //arr应该是动态开辟的空间
	}
	ps->arr = NULL;  //最本质的内存上面的东西
	ps->size = ps->capacity = 0;
}

将arr指针free掉后设置为空，防止其形成野指针，然后将结构体中的size和capacity全部设置为0,这里需要注意的是顺序表最本质上还是数组，是内存上事实存在的空间，而不是仅仅修改某一个数字而已哈。
3、接下来的操作是顺序表的打印

void SLPrint(SL* ps);

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

当然这里如果是用C++的话会更好一点，因为%d就只能打印整型，如果之后修改存储的类型的话，还需要将这里一并修改掉。

4、接下来是检查顺序表的容量大小是否足够，这个操作实际上是为了在插入数据的时候判断空间是否足够而产生的方法，如果空间足够就插入数据，不够的话就要句容。
检查容量分为两种情况，第一种是第一次检查容量是0，我们选择随便给他赋一个初值（不是简单的赋值，而是内存的实际开辟！）第二种情况是：不是0，我们选择将容量扩充为原来的2倍到3倍（这是有数学原理的，感兴趣的小伙伴可以去搜一搜）

void SLCheckCapacity(SL* ps);

void SLCheckCapacity(SL* ps) 
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, newCapacity * sizeof(SLDatatype));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
		//capacity的值已经得到改变
	}
}

在这里我们第一次检查的时候将空间大小设置为4个SLDatatype类型的大小，使用的是一个三目表达式：如果capacity为0就赋4，否则赋为原来的两倍，将这个值交给newCapacit保存。并且将capacity更新。
5、顺序表在尾部位置插入数据（尾插）

void SLPushBack(SL* ps, SLDatatype x);

首先我们需要断言传入的参数ps是否是空指针，然后检查空间容量是否足够我们进行尾部插入的操作，由于数组的下标是从0开始，因此size的下标的位置是数组目前最后的元素的后一个位置。我们只需要再size位置插入我们需要的数据，然后更新size即可。

void SLPushBack(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

6、顺序表的头部插入数据，也就是在下标为0的位置插入数据。还是和尾部插入数据一样需要assert断言ps指针，并且检查空间的容量大小。之后我们要将数组arr里面的每一个值都向后移动一位，空出0下标的位置，然后插入数据。

void SLPushFront(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);

	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

7、顺序表的删除数据（尾部删除）,我们要判断是否有数据能够让我们进行删除，也就是size不能为0，接下来我们要去删除最后一个数据，有人可能会让他设置为0之类的，事实上我们只需要让size–即可，这样的话无论后续的打印还是其他操作，那个元素实际上并没有对操作产生任何的影响。

void SLPopBack(SL* ps);

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);

	ps->size--;
}

8、顺序表的头删操作，还是一样先断言ps和size不能为空，然后从下标为1的元素开始向前进行覆盖。最后更新size。

void SLPopFront(SL* ps);


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];
	}
	ps->size--;
}

9、在指定的位置之前插入数据

void SLInsert(SL* ps, SLDatatype x, int pos);

首先断言ps不能为空指针，并且检查空间容量是否足够，否则进行扩容处理。
pos的取值也不是任意的，它在0到size时间，特殊的是如果是0则就是头插，如果是size则相当于尾插。从pos的位置开始将pos以及它之后的元素全部向后移动一位,留出pos的位置，然后插入我们所需要的数据x.

void SLInsert(SL* ps, SLDatatype x, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}

	ps->arr[pos] = x;
	ps->size++;
}

10、删除指定位置的数据

void SLErase(SL* ps, int pos);

断言的操作和9一样，在此基础上我们需要将pos+1位置以及之后的元素向前覆盖即可。

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;  //very good
}

11、在顺序表中查找我们所需要的数据，如果能找到则返回下标，找不到的话则返回-1.

int SLFind(SL* PS, SLDatatype x);

只需要遍历arr即可。

int SLFind(SL* ps, SLDatatype x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;  //如果没有找到的情况下
}

以上便是顺序表所有的操作了，接下来我们在test.c中测试我们所写的代码块。

#include "SeqList.h"

void SLtest01()
{
	SL s;
	SLInit(&s);

	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);
}
int main()
{
	SLtest01();
	return 0;
}

首先我们定义一个结构体（顺序表）s,然后对塔进行初始化，接下俩尾插1,2，3,4，5,6，接下来打印顺序表。
在这里插入图片描述
我们可以看到测试的是正确的。还有很多操作留给小伙伴们自己去进行测试啦~
顺序表的介绍就到这里结束了，最后附上所有的代码块

SeqList.h

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

//定义动态顺序表的结构
typedef int SLDatatype;

typedef struct SeqList
{
	SLDatatype* arr;
	int capacity;
	int size;
}SL;



//第一个操作：顺序表的初始化
void SLInit(SL* ps);


//第二个操作，顺序表的销毁
void SLDestroy(SL* ps);

//第三个操作，顺序表的打印
void SLPrint(SL* ps);

//第四个操作，顺序表的插入数据
void SLPushBack(SL* ps, SLDatatype x);
void SLPushFront(SL* ps, SLDatatype x);

//第五个操作，删除数据
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//第六个操作，在指定的位置之前插入数据
void SLInsert(SL* ps, SLDatatype x, int pos);

//第七个操作，删除指定位置的数据
void SLErase(SL* ps, int pos);

//第八个操作，找到指定的元素
int SLFind(SL* PS, SLDatatype x);

void SLCheckCapacity(SL* ps);

SeqList.c

#include "SeqList.h"

//第一个操作，初始化动态顺序表
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//第二个操作，销毁动态顺序表
void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);  //arr应该是动态开辟的空间
	}
	ps->arr = NULL;  //最本质的内存上面的东西
	ps->size = ps->capacity = 0;


}

//*号操作，检查顺序表的容量是否足够
void SLCheckCapacity(SL* ps)  //实际上这里并没有在头文件中申明
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, newCapacity * sizeof(SLDatatype));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
		//capacity的值已经得到改变
	}
}

//第四个操作插入数据
void SLPushBack(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

void SLPushFront(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);

	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

//第三个操作
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//第五个操作删除，包括的是头删和尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);

	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];
	}
	ps->size--;
}

//第六个操作
void SLInsert(SL* ps, SLDatatype x, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}

	ps->arr[pos] = x;
	ps->size++;
}

//第七个操作，删除指定位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;  //very good
}

int SLFind(SL* ps, SLDatatype x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;  //如果没有找到的情况下
}

test.c

#include "SeqList.h"

void SLtest01()
{
	SL s;
	SLInit(&s);

	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	//SLPushBack(NULL, 6);

	SLPrint(&s);

	//SLPushFront(&s, 1);
	//SLPushFront(&s, 2);
	//SLPushFront(&s, 3);
	//SLPushFront(&s, 4);
	//SLPrint(&s); //4 3 2 1

	//SLPopBack(&s);
	//SLPrint(&s);
	//SLPopBack(&s);
	//SLPrint(&s);
	//SLPopBack(&s);
	//SLPrint(&s);
	//SLPopBack(&s);
	//SLPrint(&s);
	//SLPopBack(&s);
	//SLPrint(&s);
	//
	//SLPopFront(&s);
	//SLPrint(&s);
	//SLPopFront(&s);
	//SLPrint(&s);
	//SLPopFront(&s);
	//SLPrint(&s);
	//SLPopFront(&s);
	//SLPrint(&s);
	//SLPopFront(&s);
	//SLPrint(&s);

	/*SLInsert(&s, 11, 0);
	SLPrint(&s);
	SLInsert(&s, 22, s.size);
	SLPrint(&s);
	SLInsert(&s, 33, 1);
	SLPrint(&s);
	int find = SLFind(&s, 222);
	if (find < 0)
	{
		printf("not found\n");
	}
	else
	{
		printf("found it always\n");
	}
	SLDestroy(&s);*/
}
	


int main()
{
	SLtest01();
	return 0;
}
favour_you___
关注
[C语言实现]数据结构——顺序表详解
FlashRider的干货分享小窝
03-01 883
C语言实现的比较易懂的数据结构顺序表实现
C语言之 数据结构入门——顺序表的构造
tq02的博客
12-27 3435
顺序表的删、插、增、查、扩等详解，且结尾附带完整代码
C语言实现数据结构——顺序表
chfens的博客
03-14 2234
C语言实现顺序表的增删查改（严蔚敏C语言第二版）
数据结构——顺序表（C语言编写）
新手小白
09-17 8193
数据结构，顺序表应用 插入、删除、合并...
C语言《数据结构》——顺序表的增，删，查，改。
qq_59931372的博客
04-16 3951
构建顺序表进行数据的查询，删除，增容等操作。
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 7373
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
数据结构C语言——顺序表
zsjsdsg666的博客
05-14 1564
数据结构C语言——顺序表 一、实验目的 1．掌握线性表的存储结构及相关的操作； 2．熟悉对顺序表的一些基本操作，如初始化、插入、删除等； 3．用C语言编制程序，程序中写出详细注释； 4．给出测试结果，验证程序的正确性。 二、实验内容 1．建立一个长度为N的顺序表。 2．输出该顺序表的各个元素以及相应的下标。 3．在顺序表的第i个位置里插入元素x，并且输出插入元素后顺序表中各个元素以及相应的下标。 4．删除顺序标中第i个位置的元素，并且输出删除元素后顺序表中各个元素以及相应的下标。 5．在顺序表中找到x元素，
【数据结构】C语言实现基本顺序表——增删查改
2301_77438812的博客
10-30 553
静态顺序表的定长数组导致N定大了，空 间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间 大小，所以下面我们实现动态顺序表。任意位置插入：void SLInsert(SL* psl, int pos, SLDataType x)然后我们就可以实现增删查改了，为了保证函数的正确性，建议写一个函数就自行测试以下。为了便于检查，我们先对顺序表的初始化，打印，和销毁函数进行实现。打印：void SLDestroy(SL* psl)2：动态顺序表：使用动态开辟的数组存储。
C语言数据结构——顺序表多项式
JianZha
04-11 886
#include "fatal.h" #define MaxDegree 100 // 幂的最大次数是100 typedef struct { int CoeffArray[MaxDegree + 1]; // 系数数组，这里定义了数组是很大的，所以下面要单独用一个HighPower来存最高次幂 int HighPower; //高次幂 }* Polynomial; // 将多项式初始化为零的过程 void ZeroPolynomial(Polynomial Poly) {
数据结构C语言版 —— 顺序表增删改查实现
爱敲代码的三毛的博客
12-14 1522
顺序表的插入和删除时间复杂度为O(N)O(N)O(N)顺序表的扩容使用的是realloc，如果后面的空间不够就会重新开辟新的空间，再把数据拷贝到新的空间，这样就会有一定的额性能消耗顺序表存在着一定的资源浪费，比如当前顺序表的容量为200，当放满之后再插入10个元素，就会进行2倍扩容到400，此时就浪费了190个数据空间。我们发现顺序表存在着一定缺陷，如果想不那么浪费空间就想着扩容扩少一点，但扩容小了如果有大量数据插入又会存着不断扩容的情况，那么又会有着性能的消耗。
数据结构C语言——静态顺序表的实现
m0_59086544的博客
06-17 509
本文章主要是介绍关于数据结构中用C语言来实现顺序表的一些基本操作。
数据结构实验——顺序表操作
g332273438的博客
05-17 2642
数据结构实验C++代码实现
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2254
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
数据结构C语言——动态顺序表的实现
m0_59086544的博客
06-17 876
本篇文章主要介绍的是数据结构中使用C语言来实现动态顺序表的一些基本操作。
王道数据结构——C语言实现
qq_46000312的博客
08-31 1054
王道数据结构—顺序表的C语言实现方法（已上机）
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1209
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1028
本文介绍了数据结构中的AVL树，给出了C++的代码实现
C~排序算法
weixin_60461563的博客
09-27 1116
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
单链表的增删改查（数据结构）
最新发布
m0_62048999的博客
09-29 1085
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值