顺序表详解(为后续通讯录项目做准备)

已于 2024-03-14 23:41:37 修改
阅读量893 收藏 18
点赞数 29
文章标签： 数据结构 算法 c#
于 2024-03-14 23:36:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80464369/article/details/136620947
版权
本文详细介绍了顺序表的概念，包括静态和动态顺序表的区别，以及如何通过数组实现增删查改等操作。提供了完整的C语言实现，包括初始化、销毁、头部插入、尾部插入、查找和打印功能的源码示例。
摘要由CSDN通过智能技术生成

一.内容总结

本篇博客会详细讲解什么是顺序表，如何实现顺序表的各种功能(增加，查找，删除，插入等等)。

二.什么是顺序表

顺序表是线性表的一种，其物理结构上与逻辑结构上都是线性的。其底层结构是数组，通过对数组的封装，实现了常用的增删查改等接口

三.实现顺序表

3.1 静态顺序表与动态顺序表

数组有固定大小的，也可以通过动态内存管理来调整数组空间的大小，就分为静态顺序表和动态顺序表，考虑到对空间的利用率，一般使用动态顺序表

3.2 顺序表结构

3.2.1 静态顺序表

是由空间大小不变的数组封装完成的，只需知道其有效数据个数即可实现增删查改等功能

typedef int SLDataType;
#define N 7
typedef struct SeqList
{  
   SLDataType arr[N];
   int size;
}SL;

3.2.2 动态顺序表

因为我们可以调节其空间的大小，所以不仅需要有效数据的个数，还需要七当前空间的大小，一般我们每次调整其空间的大小至其1.5倍或2倍。

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr; //动态内存管理
	int size;    //有效数据个数
	int capacity;//空间大小
}SL;

3.3实现讲解

我们要设置三个文件，一个头文件，进行函数声明，一个实现功能（函数）的文件，一个测试文件

3.3.1 头文件

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

#define N 7
//typedef int SLDataType;
//typedef struct SeqList
//{
//	SLDataType arr[N];
//	int size;
//}SL;
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr; //动态内存管理
	int size;    //有效数据个数
	int capacity;//空间大小
}SL;

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


//顺序表的头部插入与尾部插入
void SLPushFront(SL* ps,SLDataType x);
void SLPushBack(SL* ps,SLDataType x);

//顺序表的头部删除与尾部删除
void SLPopFront(SL* ps);
void SLPopBack(SL* ps);

//在当前位置的前一个位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x);
//删除当前位置数据
void SLErase(SL* ps, int pos);

//查找数据
void SLFind(SL* ps, SLDataType x);


//打印顺序表->进行测试功能
void SLPrint(SL* ps);

3.3.2 功能实现文件

1.顺序表的初始化

实现代码

#include "SeqList.h"

//顺序表的初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;

}

测试代码

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void SLTest01()
{
	//顺序表的初始化
	SL sl;  //--sl是我创建的一个结构体
	SLInit(&sl); //将sl的地址传过去，若只传sl，就是传值调用，在SeqList中的
	             //只是一份sl的临时拷贝，不能初始化sl
}


int main()
{
	SLTest01();
	return 0;
}
2.顺序表的打印

要检验写的功能是否能成功实现，最直观的方法就i时将其打印出来

在SeqList.c中

//顺序表的打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d", ps->arr[i]);
	}
	//注意，这里用%d只是因为SLDataType暂时是int
	printf("\n");
}
3.顺序表的尾部插入

尾部插入分为两种情况 1.空间已经满了，我们需要进行空间的扩大，但是我们待会要写的在指定位置前插入数据也可能是在空间已满的条件下，代码会重复，所以我们直接封装一个函数判断空间是否足够，不够扩大

2和3是同一种--空间未满，直接在arr[size-1]位置插入数据即可

检查空间函数
//检查空间是否充足
void SLCheckCapacity(SL* ps)
{
	if(ps->capacity==ps->size)
		{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
		//初始化时capacity是0 若我们直接写 capacity*=2; 那空间大小就是0*2==0；
		//所以用一个三目运算符判断capacity是否为0
		//若为0 --- 多给点 给个4 ，若不是0，正常扩大2倍（也可以是1.5倍/1.25倍数等等等等）
		//开始扩大空间
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(ps) * newCapacity);
		//记得写sizeof(ps),要不然只扩大4个比特
		if (tmp == NULL)//防止扩大失败返回空指针
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
		}
}

尾插函数

void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);

		SLCheckCapacity(ps);

	//空间经过检查足够，开始尾部插入
	ps->arr[ps->size] = x;
	ps->size++;

}
4.顺序表的头部插入

注意：为防止覆盖数据，这里的数据必须从最后一个开始向后移动

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++;
}
5.顺序表的头部删除

首先，这里的删除并不是你把要删除的位置的数据改成一个不用的值，而是让这里的数据被前面覆盖。从最左边开始，全部数据向左挪动

void SLPopFront(SL* ps)
{
	assert(ps);
	//既然要删除，就不能传空数组
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		//arr[size-2] = arr[size-1];
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
6.顺序表的尾部删除

明确删除的定义（我不去使用这个数据了），就可以看出非常简单，只需要把size--即可

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}
7.实现在当前位置的前一个位置插入数据

只需要把pos位置及其后面的数据全部向后挪动一位即可

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//注意对pos也有要求,pos必需>=0 &&pos<=size,可以向等，因为空间是足够的，经过检查后，capacity>size
	assert(pos >= 0 && pos <= ps->size);
	for (int i =ps->size;i>pos;i-- )
	{
		//arr[pos+1] = arr[pos];
		ps->arr[i] = ps->arr[i-1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
8.实现删除指定位置数据

只需要将删除位置之后的数据向前挪动一位，将要删除的数据覆盖就行了

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);//这次不能等于size了，size位置并没有数据
	for (int i = pos; i<ps->size-1;i++)
	{
		ps->arr[i] = ps->arr[i+1];
		//arr[pos] = arr[pos+1]
	}
	ps->size--;
}
9.查找数据

很简单，只要遍历数组找到相同的即可

void SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int b = -1;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			printf("%d ", i);
			b = 1;
		}
	}
	if (b == -1)
	{
		printf("找不到该数据\n");
	}
}
10.销毁顺序表

只需要释放空间，指针设为空，size、capacity归0即可

void SLDestroy(SL* ps)
{
	assert(ps);
	//但如果arr还没有被分配空间(初始时)，就无需释放空间了
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
	//ps是函数的临时变量，系统自动销毁，那边传过来的的不是指针的地址，而是&sl,即结构体的地址
}

3.4 全部代码呈现

1.头文件

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

#define N 7
//typedef int SLDataType;
//typedef struct SeqList
//{
//	SLDataType arr[N];
//	int size;
//}SL;
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr; //动态内存管理
	int size;    //有效数据个数
	int capacity;//空间大小
}SL;

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


//顺序表的头部插入与尾部插入
void SLPushFront(SL* ps,SLDataType x);
void SLPushBack(SL* ps,SLDataType x);

//顺序表的头部删除与尾部删除
void SLPopFront(SL* ps);
void SLPopBack(SL* ps);

//在当前位置的前一个位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x);
//删除当前位置数据
void SLErase(SL* ps, int pos);

//查找数据
void SLFind(SL* ps, SLDataType x);


//打印顺序表->进行测试功能
void SLPrint(SL* ps);

2.功能实现文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

//顺序表的初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;

}

//检查空间是否充足
void SLCheckCapacity(SL* ps)
{
	if(ps->capacity==ps->size)
		{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
		//初始化时capacity是0 若我们直接写 capacity*=2; 那空间大小就是0*2==0；
		//所以用一个三目运算符判断capacity是否为0
		//若为0 --- 多给点 给个4 ，若不是0，正常扩大2倍（也可以是1.5倍/1.25倍数等等等等）
		//开始扩大空间
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(ps) * newCapacity);
		//记得写sizeof(ps),要不然只扩大4个比特
		if (tmp == NULL)//防止扩大失败返回空指针
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
		}
}

//顺序表的头部插入与尾部插入
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 SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);

		SLCheckCapacity(ps);

	//空间经过检查足够，开始尾部插入
	ps->arr[ps->size] = x;
	ps->size++;

}

//顺序表的头部删除与尾部删除
void SLPopFront(SL* ps)
{
	assert(ps);
	//既然要删除，就不能传空数组
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		//arr[size-2] = arr[size-1];
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}

//在当前位置的前一个位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//注意对pos也有要求,pos必需>=0 &&pos<=size,可以向等，因为空间是足够的，经过检查后，capacity>size
	assert(pos >= 0 && pos <= ps->size);
	for (int i =ps->size;i>pos;i-- )
	{
		//arr[pos+1] = arr[pos];
		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);//这次不能等于size了，size位置并没有数据
	for (int i = pos; i<ps->size-1;i++)
	{
		ps->arr[i] = ps->arr[i+1];
		//arr[pos] = arr[pos+1]
	}
	ps->size--;
}

//查找数据
void SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int b = -1;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			printf("%d ", i);
			b = 1;
		}
	}
	if (b == -1)
	{
		printf("找不到该数据\n");
	}
}

void SLDestroy(SL* ps)
{
	assert(ps);
	//但如果arr还没有被分配空间(初始时)，就无需释放空间了
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
	//ps是函数的临时变量，系统自动销毁，那边传过来的的不是指针的地址，而是&sl,即结构体的地址
}

//顺序表的打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//注意，这里用%d只是因为SLDataType暂时是int
	printf("\n");
}

3.测试文件

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void SLTest01()
{
	//顺序表的初始化
	SL sl;  //--sl是我创建的一个结构体
	SLInit(&sl); //将sl的地址传过去，若只传sl，就是传值调用，在SeqList中的
	             //只是一份sl的临时拷贝，不能初始化sl
	/*SLPrint(&sl);*/
	SLPushBack(&sl,1);
	SLPushBack(&sl,2);
	SLPushBack(&sl,3);
	SLPrint(&sl);
	SLPushFront(&sl, 6);
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 4);
	SLPrint(&sl);
	/*SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopBack(&sl);*/
	/*SLErase(&sl, 4);*/
	/*SLPrint(&sl);*/
	SLFind(&sl, 100);
	SLDestroy(&sl);
}


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

四、byebye！，越来越好！

Meteor_visitor
关注
  • 29
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
华农c语言程序设计 通讯录 实验报告.pdf
11-10
【知识点详解】 1. **C语言程序设计**：通讯录程序设计是基于C语言的，C语言是一种底层、高效且灵活的编程语言，适合用于系统级编程和开发各种应用程序。在C语言中，程序员需要直接管理内存，使用指针进行数据操作...
tongxunlu.zip_C++_
08-11
《C++实现的通讯录管理系统详解》 C++是一种强大且灵活的编程语言，它以其高效、面向对象的特性在软件开发领域广泛应用。...同时，这样的项目有助于提升问题解决能力，为后续更复杂的软件开发奠定基础。
顺序表详解
m0_55698213的博客
10-05 507
本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。1、顺序表概念顺序表是在计算机内存中以数组的形式保存的线性表，线性表的的顺序存储是指用一组地址连续的存储单元一次存储线性表中的各个元素，使得线性表中的逻辑结构上相邻的元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结果的线性表通常称为线性表。顺序表是一种常见的数据结构，被广泛应用于各种应用程序和算法中，如排序、查找、数据处理等。2、顺序表分类1.静态顺序表：适应定长数组存储。
【数据结构】详解顺序表
weixin_60371270的博客
10-05 2990
本文主要讲述了线性表之顺序表的概念和分类以及接口实现。
顺序表的运用（通讯录）
Frenemy__的博客
04-25 511
在这里我们先要单独创建一个结构体来储存接收联系人的信息，最后再用尾插将这个结构体存储的联系人数据并入将要打印的con中。接下来的代码实现很多都利用到了前面的顺序表，我之前有顺序表的详解，具体可以去我空间回顾。要实现通讯录，我们就得利用前面所学的顺序表，因为通讯录的底层数据结构就是顺序表。将每个联系人的信息储存起来，这里我们储存联系人的姓名，性别，年龄，电话，住址。在完成程序功能的实现后，我们还要进行输入界面的创建。为方便后续修改，这里的数组中的值是自己定义的。打印出一个界面的样子。
初阶数据结构——顺序表（详解）
2302_80023639的博客
02-26 1170
数据结构，就是数据和结构我们平常看到的各种页面，每个人的身份信息等等，这些都是数据而结构，就是我们用不同的方式管理数据，看个例子：我们看到百度热搜部分，数据以 1、2、3、4、5 的方式被管理了起来，这是一种结构再比如我们去饭店吃饭，我们有时可能需要拿号等位置，因为饭店需要以这种方式管理顾客，才能防止场面过于混乱，这也是一种结构而我们的数据在我们的电脑里也需要被管理起来，所以才有了数据结构至此，我们初阶数据结构里，顺序表的相关知识就讲完啦接下来会给大家带来顺序表的应用——通讯录的相关讲解。
打开数据结构的大门——顺序表详解
effort123_的博客
06-29 716
其实这俩的区别是显而易见的，一个是一个定长的数组，一个是动态的数组，静态顺序表最大的缺点其实就是这个定长，假设我们想要存放一个100个元素的数组，但是此时静态顺序表中数组里面仅仅可以存放99个元素，那么这个时候我们又得大费周章的把数组元素个数增大，这样会显得很麻烦，可读性很差，但是此时对于动态的数组可就不是问题了，只要进行相应的扩容，就可以解决这个问题了，所以通过比较来看静态顺序表的局限性太大了，动态顺序表就灵活了很多，所以之后小编更推荐大家用动态顺序表来进行代码的书写。
【数据结构】C语言实现顺序表万字详解(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
10-28 752
使用C语言实现顺序表程序的新手入门万字详解,包括每个函数的设计原理图示,设计思路,每步的注释以及程序完整实现代码.
【数据结构】- 线性表+顺序表
小沈.的博客
04-17 512
数据结构学习第三弹 --- 线性表+顺序表
【C语言实战项目】通讯录
C/C++领域,数据结构,linux,MySQl学习者
08-14 1951
C语言实战项目之通讯录程序万字详解.
数据结构初阶--顺序表和链表
weixin_67916525的博客
02-19 418
顺序表本质上就是数组。但是在此之上，顺序表要求存储的数据必须是连续紧挨着的，不能跳跃。用一段物理地址连续的存储单元依次存储数据元素的线性结构。线性表在逻辑上是线性结构，也就说是连续的一条直线。顺序表的物理结构和逻辑结构是一致的。链表是用指针把一块一块内存链接起来。
【数据结构入门】二叉树之堆排序及链式二叉树
KevinRay_0854的博客
08-27 1020
堆排序是一种使用堆数据结构的排序算法。堆是一种完全二叉树，且满足堆属性，即每个节点的值都大于（或小于）它的子节点的值。 二叉树的遍历有三种方式：前序遍历、中序遍历、后序遍历。这三种遍历方式都是深度优先遍历。
【笔记】数据结构——8月27日
m0_52024881的博客
08-27 1355
考研用笔记
数据结构——顺序表
m0_61965705的博客
08-27 598
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
【数据结构】-----哈希
m0_73470633的博客
08-29 1687
一文看懂哈希结构！
数据结构—顺序表
qq_43344188的博客
08-27 420
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
Linux 数据结构 哈希表 排序
最新发布
mxyzhy的博客
08-31 222
数据结构 哈希表
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值