【数据结构初阶】顺序表SeqList

已于 2023-11-13 19:04:25 修改
阅读量390 收藏
点赞数
分类专栏： 数据结构初阶 文章标签： 数据结构
于 2023-11-12 14:01:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsj1345714539566/article/details/134347485
版权

描述

顺序表我们可以把它想象成在一个表格里面填数据，并对数据做调整；

那我们的第一个问题是：怎么样在创建出足够的空间呢？

我们可以去堆上申请，用一个指针指向一块空间，如果申请的空间不够，我们可以再realloc申请出来。

我们的第二个问题是：怎么样标记我们用了多少空间呢？

这时我们就需要一个变量来记录我们当前的用到第几个“格子”（即用了多少空间），我们这里用size来表示：

我们的第三个问题是：怎么样知道我们有空间呢？

这时我们就需要一个变量来记录我们“格子”总数（即拥有多少空间），我们这里用capacity来表示：

所以（在.h文件中）我们线性表的结构体描述为：

typedef int SLDataType;

typedef struct SeList
{
	SLDataType* a;
	int size;
	int capacity;
}SL;

组织

  1. 初始化
  2. 释放
  3. 尾插
  4. 尾删
  5. 头插
  6. 头删
  7. 指定位置删除
  8. 指定位置插入
  9. 查找指定元素

1.初始化

把我们描述出来的顺序表结构体里的变量初始化

在.h文件中：

因为要对创建出来的结构体里的内容进行修改，所以函数要进行传址调用；

在.c文件中:

我们用malloc来开辟空间,同时注意检查malloc；

因为我们刚刚开辟空间，并没有往顺序表里增删查改 所以此时size为0；

而我们的capacity就是在malloc开辟的空间大小。

void SLInit(SL* ps)
{
	assert(ps->a);

	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

2.释放

将描述出来的顺序表结构体里的变量逐个进行释放；

在.h 文件中：

在.c文件中：

首先是指针a，需要使用free函数将其释放，还需要注意的是free后，需要将a置空，避免出现野指针；

因为size和capacity是临时变量储存在栈上，函数调用结束后会自动释放，我们这里把它改为0就可以了。

void SLDestroy(SL* ps)
{
	assert(ps->a);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

3.尾插

向顺序表的尾部插入数据；

在.h 文件中：

在.c文件中：

尾插数据时，首先，需要判断capacity（空间）是否足够，如果不够需要扩容，这里我们写个扩容函数：

扩容我们用realloc函数，最后要返回ps至尾插函数判断是否为空；

接着，才能将数据尾插；

最后别忘了调整size的位置；

SL* SLExpand(SL* ps)
{
	assert(ps->a);
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType)* ps->capacity*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return NULL;
		}
		ps->capacity *=2;
		ps->a = tmp;
	}
	return ps;
}

void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps->a);
	//扩容
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}
	ps->a[ps->size] = x;
	ps->size++;

}

4.尾删

将顺序表的尾部删除；

在.h 文件中：

在.c 文件中：

因为顺序表是从开始连续存储size个数据，不能单独释放那一块区域，所以我们直接将size--就可以了，如果往后插入的话，就直接把数据覆盖；

assert（）如果当capacity为空的时候还尾删时会报错,并且终止程序；

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

5.头插

向顺序表的头部插入数据；

在.h 文件中：

在.c 文件中：

首先，我们得先判断空间是否足够，如果不够就扩容；

第二步：把数据往后移一位，数据从最后一位开始向后移动；

第三步：进行数据头插，别忘了把size的大小改改；

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps->a);

	//扩容
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}

	//移动数据
	for (int i = ps->size; i >0 ; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}

	//头插
	ps->a[0] = x;
	ps->size++;

}

6.头删

将顺序表的头部数据删除；

在.h 文件中：

在.c 文件中：

我们只需要将从第二位数据开始往前移动，把前一位的数据覆盖就可以达到头删的效果；

void SLPopFront(SL* ps)
{
	assert(ps->a);
	assert(ps->size > 0);
	for (int i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}

	ps->size--;
}

7.指定位置删除

将顺序表的指定位置数据删除；

在.h 文件中：

在.c 文件中：

首先，要先用assert检查一下空间和pos的值是否合理；

如果删除的数据是最后一个就直接尾删；

如果如果删除的数据不是最后一个就需要移动数据覆盖，类似于头删；

void SLErase(SL* ps, int pos)
{
	assert(ps->a);
	assert(pos >= 0&&pos<ps->size);

	//如果pos是最后一个数据，尾删
	if (pos == ps->size - 1)
	{
		SLPopBack(ps);
	}

	else
	{
		for (int i = pos; i < ps->size; i++)
		{
			ps->a[i] = ps->a[i + 1];
		}
		ps->size--;
	}

	
}

8.指定位置插入

将顺序表的指定位置数据插入；

在.h 文件中：

在.c 文件中：

首先，要先用assert检查一下空间和pos的值是否合理；

如果插入的数据是最后一个就直接尾插；

如果如果插入的数据不是最后一个就需要移动数据，再插入数据，类似于头插；

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

	//判断容量
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}

	//尾插
	if (pos == ps->size - 1)
	{
		SLPushBack(ps,x);
	}
	else
	{
		for (int i = ps->size; i > pos; i--)
		{
			ps->a[i] = ps->a[i - 1];
		}
		ps->size++;
		ps->a[pos] = x;
	}
}

9.查找指定元素

在顺序表中查找指定数据，并输出其下表，和在该表中的个数；

在.h 文件中：

在.c 文件中：

for循环遍历一下顺序表，如果遍历过程中找到了直接打印其下标，并用一个变量记录它出现的此数。

出循环后打印其和在该表中出现的个数。

void SLFindPoint(SL* ps, SLDataType x)
{
	assert(ps->a);
	
	int cnt = 0;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			cnt++;
			printf("找到了第%d个，下标为:%d\n",cnt, i);
		}
	}
	if (cnt == 0)
	{
		printf("抱歉，无该数据\n");
	}
	else
	{
		printf("共找到%d个数据\n", cnt);
	}
}

整个程序

.h文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>

typedef int SLDataType;
#define INIT_CAPACITY 4

typedef struct SeList
{
	SLDataType* a;
	int size;
	int capacity;
}SL;

void SLPrint(SL* ps);

void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPushBack(SL* ps,SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
void SLErase(SL* ps,int pos);
void SLInsert(SL* ps, int pos, SLDataType x);
void SLFindPoint(SL* ps, SLDataType x);

.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"


void SLPrint(SL* ps)
{
	assert(ps->a);

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


void SLInit(SL* ps)
{
	assert(ps->a);

	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

void SLDestroy(SL* ps)
{
	assert(ps->a);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

SL* SLExpand(SL* ps)
{
	assert(ps->a);
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType)* ps->capacity*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return NULL;
		}
		ps->capacity *=2;
		ps->a = tmp;
	}
	return ps;
}

void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps->a);
	//扩容
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}
	ps->a[ps->size] = x;
	ps->size++;

}

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

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps->a);

	//扩容
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}

	//移动数据
	for (int i = ps->size; i >0 ; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}

	//头插
	ps->a[0] = x;
	ps->size++;

}

void SLPopFront(SL* ps)
{
	assert(ps->a);
	assert(ps->size > 0);
	for (int i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}

	ps->size--;
}

void SLErase(SL* ps, int pos)
{
	assert(ps->a);
	assert(pos >= 0&&pos<ps->size);

	//如果pos是最后一个数据，尾删
	if (pos == ps->size - 1)
	{
		SLPopBack(ps);
	}

	else
	{
		for (int i = pos; i < ps->size; i++)
		{
			ps->a[i] = ps->a[i + 1];
		}
		ps->size--;
	}

	
}

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

	//判断容量
	if (ps->size == ps->capacity)
	{
		SL* ret = SLExpand(ps);
		if (ret == NULL)
		{
			return;
		}
	}

	//尾插
	if (pos == ps->size - 1)
	{
		SLPushBack(ps,x);
	}
	else
	{
		for (int i = ps->size; i > pos; i--)
		{
			ps->a[i] = ps->a[i - 1];
		}
		ps->size++;
		ps->a[pos] = x;
	}
}

void SLFindPoint(SL* ps, SLDataType x)
{
	assert(ps->a);
	
	int cnt = 0;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			cnt++;
			printf("找到了第%d个，下标为:%d\n",cnt, i);
		}
	}
	if (cnt == 0)
	{
		printf("抱歉，无该数据\n");
	}
	else
	{
		printf("共找到%d个数据\n", cnt);
	}
}

吃不胖的熊猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2227
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
数据结构 —— 第一个程序 【顺序表】
世界很大
09-24 839
//操作的开始*********************************** //操作的进行 //操作的结束*********************************** #include #include #include #define MAX 1000 #define MAXM 10 #define OK 1 #define OVERFLOW -1 #define ER
数据结构SeqList.h头文件
03-07
包含数据结构顺序表的基本操作函数（初始化，插入，删除，查找等）
数据结构-动态顺序表
tzy134679的博客
11-05 726
#pragma once #include <stdio.h> #include<string.h> #include<stdlib.h> typedef int SQDataType; typedef struct SeqList { SQDataType* a; int size; //有效数据的个数 int capacity; //容量 }SL; void SeqListInit(SL* ps);//初始化动态顺序表 void SeqListPus.
【数据结构】顺序表(SeqList)（增、删、查、改）详解
Elena's Blog
07-27 3010
在数据结构中，如果要访问或者修改数据结构中的数据不要直接访问，而是应该去调用它的函数来访问和修改，这样会更加规范和安全，也更方便检查出是否出现了越界等错误情况。数组越界是不一定报错的，系统对越界的检查是设岗检查。越界读（读了不属于自己的数据），一般是检查不出来的，往往并不会造成内存奔溃。越界写（缓冲区溢出）如果是修改到标志位才会被检查出来，会造成数据破坏，严重会造成内存奔溃。（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）
数据结构—顺序表
luhaowei0066的博客
03-11 324
顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构地址连续的空间，一般情况下采用数组，但数组有静态数组和动态数组所以顺序表分为：静态顺序表和动态顺序表程序分为三个部分：seqlist.h（头文件）、seqlist.c（函数实现）、 main.c（测试文件）seqlist.h部分#pragma once                                             ...
C语言创建MaxSize头文件,我不知道怎样定义头文件#include<seqlist.h>
weixin_39637151的博客
05-24 1957
满意答案sgkkz3592017.10.26采纳率：50%等级：10已帮助：671人C语言的库文件中，并没有SeqList.h这个标准头文件。这个是一个自定义头文件。在数据结构教材中，使用了该名字。其中存储了顺序表的实现。该头文件内容如下：1234567891011121314151617181920212223242526272829303132333435363738394041424...
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
seqlist.h头文件
12-27
seqlist.h头文件，包含了其中的源代码。很标准的哦。
数据结构顺序表，c语言简单实现
01-12
顺序表是一种基本的数据结构，它的实现简单直观，适用于小规模数据的存储。本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过...
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-01 3320
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。本篇博客我们主要介绍一下顺序表的内容，最后会给出顺序表的应用，也就是之前拖了大家很久的通讯录动态版。
一篇博客读懂顺序表 —— Sequence-List
最新发布
m0_75186846的博客
11-01 643
当我们要实现通讯录时，我们会自定义一个 contact.h 文件来存储我们的各种声明，自定义一个 contact.c 文件来存储实现声明的函数，同时还会存在一个 test.c 来测试我们代码的可行性。在这里我们学习顺序表时，也要使用这种方式，来分割我们的代码使程序更加简洁耐看：在 SeqList.h 中，我们要声明我们需要的头文件、重新定义的类型、我们需要的函数......
数据结构-顺序表（2）
Locky136的博客
02-24 792
顺序表详解
SeqList.h (顺序表及其简单应用)
热门推荐
zhoulingjie311的专栏
04-23 1万+
<br />SeqList.h<br />//顺序表的实现 #include "stdio.h" #include "math.h" //#define MaxSize 10 //typedef int DataType; typedef struct { DataType list[MaxSize]; int size; } SeqList; //初始化列表 void ListInitiate(SeqList *L) { L->size = 0; } //得
【数据结构】顺序表
kdjjdjdjjejje128的博客
07-28 574
顺序表的实现
数据结构封装之 《SeqList顺序表》
BeiJiaan的博客
08-28 4021
数据结构封装之 《SeqList顺序表》 记录自己的学习过程，有兴趣的朋友可以加个好友，相互学习。
链表线性表的c语言实现方式 seqlist.h 和 seqlist.c
chen1540524015的博客
07-09 2364
.h 文件#ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include <stdio.h> #include <stdlib.h> #include <string.h> //线性表 //线性表顺序存储 类似于数组，存的元素节点,只有业务节点， //业务节点之间没有关系,线性关系不是链性关系，可以[]操作 typedef void List; typedef vo
完成顺序表SeqList的结构定义
03-23
顺序表SeqList的结构定义如下： typedef struct { ElemType *elem; // 存储空间基址 int length; // 当前长度 int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位) } SeqList;

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吃不胖的熊猫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值