C语言顺序表

最新推荐文章于 2024-11-09 14:42:33 发布
最新推荐文章于 2024-11-09 14:42:33 发布
阅读量779 收藏 13
点赞数 12
文章标签： c语言 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79979030/article/details/137518295
版权
本文详细介绍了动态顺序表的概念，包括静态顺序表与数组的区别，动态顺序表的实现过程，如初始化、销毁、插入、删除、查找和打印等操作的函数定义及其工作原理。
摘要由CSDN通过智能技术生成

1、顺序表的概念及结构

1.1线性表

线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。

2、顺序表分类 

·顺序表和数组的区别：

顺序表的底层结构是数组，对数组的封装，实现了常用的增删查改等接口。

·顺序表的分类

（1）静态顺序表

概念：使用定长数组存储元素 
//静态顺序表
typedef int SLDataType;
#define n 7
typedef struct SeqList
{
	SLDataType arr[n];//定长数组
	int size;//有效数据个数
}SL;

静态顺序列表的缺陷：空间给少了不够用，给多了造成空间浪费。 

（2）动态顺序表

概念：按需申请，一般是申请有效数据个数的2倍。

//动态顺序表
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size;//有效数据个数
	int capacity;//有效数据容量
}SL;

3、动态顺序的实现 

首先我们需要三个文件来存储我们的项目代码。

3.1 头文件：SeqList.h 

这个文件储存我们的方法，方便我们查看和修改。

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define INIT_CAPACITY 4
typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
    SLDataType* arr;
    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);

3.2 SeqList.c文件 

定义我们在头文件的方法。

（1）初始化顺序表

void SLInit(SL *ps)
{
    if(ps->arr)//判断arr等不等于0
    {
        ps->arr = 0;
    }
    ps->size = ps->capacity = 0;
}

 (2)销毁 

void SLDestroy(SL* ps)
{
	if (ps->arr)//有空间就需要销毁
	{
		free(ps->arr);
	}
	ps->size = ps->capacity = 0;
}

 (3)头部插入删除 / 尾部插入删除

 尾插：
//尾插

void SLPushBack(SL* ps, SLDataType x)
{
	/*温柔的解决ps为null的问题
	if (ps == NULL)
	{
		return;
	}*/
	assert(ps);//等价于assert（ps！=null）
	SLCheckCapacity(ps);//判断够不够不够增加容量
	ps->arr[ps->size++] = x;
}

在插入数据之前应当判断数组容量大小够不够。（不够则需要扩容）

扩容：
void SLCheckCapacity(SL* ps)
{
	//插入数据之前先看空间够不够
	if (ps->capacity == ps->size)//当数据个数与空间容量相同时则空间不够应用
	{
		//申请空间
		//申请空间的函数：malloc calloc realloc | int arr[100]--->增容用realloc
		//三目操作符判断空间容量
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity *sizeof(SLDataType));//要申请多大空间
		if (tmp == 0)
		{
			perror("realloc fail!");
			exit(1);
		}
		//空间申请成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
 尾删：
void SLPopBack(SL* ps)
{
	assert(ps);//传过来的数组不能为NULL
	assert(ps->size);//顺序表不为空
	--ps->size; 
}

 

头插：
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];//结束条件：arr[1] = arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}

由图可知数组内的数据整体往后移，并且size++。 

头删： 
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);//只要是删除，必须判断顺序表数据是否为0
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

 ​​​​​​​

（4）查找：

int SLFind(SL* ps, SLDataType x)
{
    for (int i = 0; i < ps->size; i++)
    {
        if (ps->arr[i] == x)
        {
            return i;
        }
    }
    //没有找到
    return -1;
}

（5）打印： 

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

（6）指定位置之前插入数据/删除指定位置数据

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//传入的pos不能超过size   
	//再插入之前看看：空间够不够
	SLCheckCapacity(ps);
	//让pos及以后的数据整体往后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//arr[pos+1] = arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}

//删除指定位置数据
void SLErase(SL* ps, int pos)
{
	assert(ps);//作用：传过来的是否是空地址
	assert(pos >= 0 && pos < ps->size);//size所指的位置没有有效数据

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

 

此处的方法我们可以理解成头删头插，当让也能理解为尾插尾删。

4.test.c文件

在这里我们可以测试我们的方法，每当定义一个方法时都可以来这里进行测试。

下面代码是一个已经完成全部测试后的代码，希望同学能够自己去测试一下自己定义的每个方法。

#include"SeqList.h"

void SLTest01()
{
	SL sl;
	SLInit(&sl);
	//ɾIJ
	//β
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(sl);//1 2 3 4

	//SLPushFront(&sl, 5);
	//SLPushFront(&sl, 6);

	//βɾ
	SLPopBack(&sl);
	SLPrint(sl);//1 2 3 
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopFront(&sl);
	SLPrint(sl);
	//...........
	SLDestroy(&sl);
}

int main()
{
	SLTest01();
	return 0;
}

 5. 总结代码

test.c :

#include"SeqList.h"

void SLTest01()
{
	SL sl;
	SLInit(&sl);
	//ɾIJ
	//β
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(sl);//1 2 3 4

	//SLPushFront(&sl, 5);
	//SLPushFront(&sl, 6);

	//βɾ
	SLPopBack(&sl);
	SLPrint(sl);//1 2 3 
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopFront(&sl);
	SLPrint(sl);
	//...........
	SLDestroy(&sl);
}

int main()
{
	SLTest01();
	return 0;
}

 SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//定义顺序表的结构

//#define N 100
//
静态顺序表
//struct SeqList
//{
//	int arr[N];
//	int size;//有效数据个数
//};

typedef int SLDataType;
//动态顺序表
typedef struct SeqList 
{
	SLDataType* arr;
	int size; //有效数据个数
	int capacity; //空间大小
}SL;

//typedef struct SeqList SL;

//顺序表初始化
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
void SLPrint(SL s);

//头部插入删除 / 尾部插入删除
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);

void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//指定位置之前插入/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

SeqList.c

#include"SeqList.h"
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//顺序表的销毁
void SLDestroy(SL* ps)
{
	if (ps->arr) //等价于  if(ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
void SLCheckCapacity(SL* ps)
{
	//插入数据之前先看空间够不够
	if (ps->capacity == ps->size)
	{
		//申请空间
		//malloc calloc realloc  int arr[100] --->增容realloc
		//三目表达式
		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;
	}
}
//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	温柔的解决方式
	//if (ps == NULL)
	//{
	//	return;
	//}
	assert(ps); //等价与assert(ps != NULL)

	//ps->arr[ps->size] = x;
	//++ps->size;
	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];//arr[1] = arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}

void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	//顺序表不为空
	//ps->arr[ps->size - 1] = -1;
	--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--;
}

 希望大家能够喜欢，如果对您有帮助可以点个赞的老铁。

Zhai0205Zzz
关注
c语言顺序表指针,从顺序表的算法看指针的妙用
weixin_33037813的博客
05-19 1838
从顺序表的算法看指针的妙用By 祥泰科学的发现往往是偶然的，我在研究算法的时候，发现了C语言指针的另类用法，技巧令人拍案叫绝，欲知详情，请看下文。首先，先看一下下面的这段代码：//定义顺序表的元素类型。应根据需要修改typedef int DataType;struct SeqList{intMAXNUM；//顺序表中最大元素的个数intn;//存放线性表中元素的个数n≤MAXNUMDa...
C语言顺序表代码
weixin_42104550的博客
08-23 3738
顺序表是数据数据结构里链表的内容，同时也是学习数据结构和深入了解以及应用C语言指针的一个好的开头，顺序表顾名思义就是一个有顺序存储结构的表了，这个表在内存中是顺序存储的，如果数据比较短 ...
c语言顺序表操作实验报告
m0_73558214的博客
09-28 1418
数据结构顺序表实验，c语言实现顺序表增删改查操作
C语言 顺序表删除
qq_38393270的博客
08-29 3612
C语言实现链表删除元素 注意删除位的合法取值 // 顺序表删除操作 # include <stdio.h> # define maxsize 10 // 定义顺序表结构体 typedef struct { int data[maxsize]; int length; }SqlList; // 初始化顺序表 void InitList(SqlList &L) { // 空表长度为0 L.length = 0; // 全赋值0 for (int i=0;i<10
C语言顺序表代码实现
weixin_56565733的博客
12-11 1508
顺序表： 顺序表的创建： 定义结构体：结构体成员包含整形数组和一个记录最后一个数据下标的整形变量： #define DATASIZE 5 typedef struct { int data[DATASIZE]; int last; }sqlist_t; 编写创建顺序表的函数：返回创建顺序表的首地址 sqlist_t *sqlist_create(void) { sqlist_t *list = NULL; list = malloc(sizeof(sqlist_t)); if(list == N
C语言 顺序表 增删改查
宏斌的博客
09-26 873
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 1024 typedef struct sqList { int data[MAXSIZE]; int last; } SequentList; SequentList *createSequentList() { SequentList *L = (SequentList *)malloc(sizeof(SequentList));
C语言顺序表的删除元素
weixin_46073538的博客
02-28 2590
#include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据类型名称 typedef int Status ; typedef int ElemType ; // struct 结构体 typedef struct sqlist{ //
C语言顺序表的初始化
weixin_46073538的博客
02-24 4368
没学过C语言，将就着看着吧！ #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据类型名称 typedef int Status ; typedef int ElemType ; // struct 结构体 typedef struct
C语言顺序表的增删查改以及实际应用（通讯录的实现）
2301_79995226的博客
04-10 1715
这样做的优点在于。
C语言顺序表的实现代码
08-29
C语言顺序表的实现代码 C语言顺序表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。本文主要为大家详细介绍了C语言实现顺序表的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 顺序表...
C语言顺序表应用
12-23
在计算机科学中，顺序表是一种基础且重要的数据结构，它在C语言中有着广泛的应用。顺序表是由一组相同类型元素按线性顺序排列的数组，它的主要操作包括添加元素、删除元素、查找元素以及对元素进行排序。接下来，...
C语言顺序表实现代码排错
09-04
C语言顺序表实现代码排错 在这篇文章中，我们将详细介绍C语言顺序表实现的方法，并提供了一个完整的示例代码。顺序表是一种常用的数据结构，它可以存储大量的数据，并提供了插入、删除、查找等操作。 首先，我们...
基于C语言的顺序表实现图书管理系统
01-06
1.动态内存管理 2.C语言编写 3.超级人性化，欢迎大家下载查询
考研要求掌握的C语言（选择排序）
最新发布
lushij的博客
11-09 128
每次进行一趟排序后，就确定一个数据的最终位置。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 2061
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
【进阶】java基础之集合(2)数据结构＜树＞
Y0UZI的博客
11-05 382
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
C 语言冒泡排序算法详解
licy__的博客
11-09 128
冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置来实现排序。尽管冒泡排序的时间复杂度较高（O(n²)），但它因其简单易懂而常用于教学目的。本文将详细介绍冒泡排序的工作原理，并提供一个用 C 语言实现的示例。冒泡排序的基本思想是通过多次遍历待排序的列表，每次遍历时比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。这样，每遍历一次，最大的元素就会像气泡一样“浮”到列表的末尾。这个过程会重复进行，直到整个列表变得有序。
C语言顺序表实现代码排错与示例
本篇文章提供了一个C语言顺序表的实现代码，并着重探讨了其中的排错过程。代码包括两个文件：`sqlist.h`头文件和`sqlist.c`实现文件。 首先，我们来看`sqlist.h`头文件： 1. 定义了数据类型`elemtype`表示元素类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值