数据结构 : 顺序表详解

于 2024-10-10 17:29:55 发布
阅读量1k 收藏 23
点赞数 22
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79262802/article/details/142722664
版权

顺序表

文章目录

前言

首先在了解顺序表之前我们要知道线性表的概念:
零个或多个数据元素的有限序列
**示例:我们所熟悉的十二星座列表就是线性表,首先线性表是一个序列,其数据元素之间是有顺序的;

线性表（linearlist）是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

一、顺序表的概念

线性表的顺序存储结构,指的是用一段物理地址连续的存储单元依次存储线性表的数据元素.
⼀般情况下采⽤数组存储.
顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝.

二、顺序表

1.顺序存储定义

顺序表也分静态顺序表和动态顺序表
本篇文章用的数据类型是结构体型

#define N 10
typedef int SLDataType;//定义数据类型为 int

//静态顺序表
struct SeqList
{
	SLDataType arr[N];//定长数组
	int size;//有效数据个数
}SL;
  1. 静态顺序表需要确定数据的大小
    这个大小不太好控制,容易造成空间浪费或者空间大小不够用
  2. 所以我们要引用动态顺序表
    动态顺序表的好处是先定义数据,不需要预先给定空间大小,后面根据需求realloc
//动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	SLDataType  size;//有效数据个数
	SLDataType capacity;//空间容量
}SL;

这里用typedef将结构体类型struct SeqList重命名为叫SL,方便后面调用
SLDataType为顺序表中的数据类型,这个数据类型在本文中为int
size为顺序表的实际长度

2.顺序表的初始化

.
初始化时这里只是开辟了一个空间并置为空指针
把结构体中的数据全初始化为0;

//顺序表的创建
void SLInit(SL* ps)//形参
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

3.顺序表的插入

插入算法的思路:

  1. 如果插入位置不合理,error;
  2. 如果顺序表的长度大于等于数组的长度,则error或动态扩容;
  3. 从最后一个元素开始向前遍历到第 x 个位置,分别将他们都向后移动一个位置;
  4. 将要插入的数据元素插入到位置 x 处;
  5. 表长 + 1;
    在这里插入图片描述

在指定位置插入

void SLInsert(SL* ps, int pos, SLDataType X)
{
	assert(ps);
	//前=:头插
	//后=:尾插
	assert(pos >= 0 && pos <= ps->size);
	//插入数据,空间够不够;
	CheckSLCapacity(ps);
	//让pos及以后的数据整体往后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = X;
	ps->size++;
}

测试一下
在这里插入图片描述

在插入之前也要先判断空间容量够不够,不够的话要申请空间
我们在里把这个代码单独封装成一个函数

void CheckSLCapacity(SL* ps)
{
	//空间够不够,申请空间
	if (ps->size == ps->capacity)
	{
		//空间不够,增加空间 
		//连续的位置(顺序表的长度)足够直接增容 
		//连续的位置不够:那就realloc 
		//1)找到新的连续的空间
		//2)拷贝旧的数据
		//3)释放旧空间
		//void* realloc(void* ptr, size_t size)(size代表的是字节)
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);//退出程序
		}
		//空间申请成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

尾插(SLPushBack)

尾插就是判断空间够不够,够的话直接插入,不够的话先扩容再插入;
尾插的话就不用考虑在指定的位置插入数据后,把后面的元素依次先后移动一位
尾插的时间复杂度为 O(1)

在这里插入图片描述

//尾插
void SLPushBack(SL* ps, SLDataType X)
{
	assert(ps!= NULL);//ps不能为空指针,不能对NULL解引用
	CheckSLCapacity(ps);
	//ps->arr[ps->size] = X;
	//++ps = size;
	ps->arr[ps->size++] = X;
}

在这里插入图片描述

头插(SLPushFront)

头插的时间复杂度为 O(N)
在这里插入图片描述

void SLPushFront(SL* ps, SLDataType Y)
{
	assert(ps);//不能给顺序表传一个空地址
	CheckSLCapacity(ps);//检查空间是否充足,不够扩容
	for (int i = ps->size; i > 0; i--)//向后遍历数组
	{
		ps->arr[i] = ps->arr[i - 1];
	
	ps->arr[0] = Y;//插入数据
	ps->size++;//表长+1
}

在这里插入图片描述

4.顺序表的删除

删除算法的思路:

如果删除位置不合理,error;
取出删除元素;
从删除元素位置开始遍历到最后一个元素位置,分别将它们都向前移动一个位置
表长 - 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];//arr[size-2] = arr[size-1]
	}
	ps->size--;
}

尾删(SLPopBack)

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	//顺序表不为空
	--ps->size;
}

头删(SLPopFront)

//头删 
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--;
}

5.顺序表的查找

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;
}

6.顺序表的输出

顺序表的输出是for循环遍历各元素并输出各元素的值

void SLPrint(SL s)
{
	if (s.size == 0)
	{
		printf("顺序表为空!");
		return 0;
	}
	printf("顺序表为: ");
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

在这里插入图片描述

7.顺序表的销毁

//顺序表的销毁
void SLDestroy(SL* ps)
{
	if (ps->arr)//等价于if(ps->arr != NULL)
	{
		free(ps->arr);//释放申请的空间
	}
	ps->arr = NULL;
	ps->size = ps->capacity == 0;
}

代码Demo

SeqList.h(函数声明)

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

#define N 10
typedef int SLDataType;

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

//typedef struct SeqList SL;两种都可以
//动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	int size;
	SLDataType capacity;
}SL;

//顺序表的创建
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
//顺序表的打印输出
void SLPrint(SL s);
//尾插
void SLPushBack(SL* ps, SLDataType X);
//头插
void SLPushFront(SL* ps, SLDataType Y);
//检查空间
void CheckSLCapacity(SL* ps);
//在指定位置插入
void SLInsert(SL* ps, int pos, SLDataType x);
//在指定位置删除
void SLErase(SL* ps, int pos );
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//查找
int SLFind(SL* ps, SLDataType x);

test.c(测试)

#include"SeqList.h"

void Test()
{
	SL s1;//结构体变量
	//初始化
	SLInit(&s1);//实参,传地址,形参的改变会影响实参
	//尾插
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPrint(s1);
	//头插
	SLPushFront(&s1, 5);
	SLPushFront(&s1, 6);
	SLPrint(s1);
	测试指定位置插入数据
	SLInsert(&s1, 0, 99);
	//SLInsert(&s1, s1.size, 99);
	SLPrint(s1);
	//测试指定位置删除
	SLErase(&s1,0);
	SLPrint(s1);
	//尾删
	SLPopBack(&s1);
	SLPrint(s1);
	//头删
	SLPopFront(&s1);
	SLPrint(s1);

	int find = SLFind(&s1, 4);
	if (find < 0)
	{
		printf("没有找到! \n");
	}
	else {
		printf("找到了,下标为%d\n", find);
	}
	SLDestroy(&s1);
}
int main()
{
	Test();
	return 0;
}

SeqList.c(函数的实现过程)

#define _CRT_SECURE_NO_WARNINGS 1
#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 CheckSLCapacity(SL* ps)
{
	//空间够不够,申请空间
	if (ps->size == ps->capacity)
	{
		//空间不够,增加空间 2n
		//连续的位置足够直接增容 
		//连续的位置不够:
		/*1)找到新的连续的空间
		2)拷贝旧的数据
		3)释放旧空间*/
		//void* realloc(void* ptr, size_t size)(size代表的是字节)
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		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 != NULL);//粗暴
	//为真-通过//为假-报错
	CheckSLCapacity(ps);
	//ps->arr[ps->size] = X;
	//++ps = size;
	ps->arr[ps->size++] = X;//后置++,先使用再++
}
//头插
void SLPushFront(SL* ps, SLDataType Y)
{
	assert(ps);
	CheckSLCapacity(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = Y;
	ps->size++;
}
//顺序表的输出
void SLPrint(SL s)
{
	if (s.size == 0)
	{
		printf("顺序表为空!");
		return 0;
	}
	printf("顺序表为: ");
	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->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--;
}
//在指定位置插入数据
void SLInsert(SL* ps, int pos, SLDataType X)
{
	assert(ps);
	//前=:头插
	//后=:尾插
	assert(pos >= 0 && pos <= ps->size);
	//插入数据,空间够不够;
	CheckSLCapacity(ps);
	//让pos及以后的数据整体往后挪动一位
	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];//arr[size-2] = arr[size-1]
	}
	ps->size--;
}
//查找数据
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;
}

总结

本文章只是个人的一些见解,如有错误请大家多多指正.

邮电部CV练习生
关注
数据结构——顺序表（初学者简易版）
AdamMaoKkk的博客
04-09 877
刚接触数据结构，看书太着急，一上来就被各种自定义的变量和函数搞得一懵一懵的 目前顺序表刚刚入门，花了两天写了一个顺序表的基础版本（对于初学者应该是比较通俗易懂的了） 欢迎各位大佬指错督促，谢谢你们 PS：以下顺序表包含操作有 创建 初始化 查找 插入 删除 #include<stdio.h> #include<stdlib.h> #define MAX 100 #def...
【数据结构】顺序表定义和基本操作
Z_sea的博客
12-11 4527
线性表主要两种结构： 顺序存储  和  链式存储： 这次写的顺序表，指的是线性表的顺序存储模式； 定义类型： #define ListInitSize 100 #define ListIncrement 10 #define LElemType int typedef struct Sqlist{ LElemType *base; int length; int...
数据结构初阶——顺序表
热门推荐
m0_64607843的博客
04-29 1万+
博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构！！！
数据结构--顺序表
最新发布
pzn2506的博客
05-25 652
但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...存放指定位置，然后把pos之后的数据整体往后移动一位，在pos位置插入所需要的数据即可。因为数组并不是定长的，可根据实际数据大小进行动态申请空间，随着数据的增加，也可进行。顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝。与插入数据原理一样，只需在所需的位置删除数据即可。在数据的头部插入数据；在数据的尾部插入数据。
数据结构——顺序表
m0_63020222的博客
03-17 4026
顺序表的基本操作（c语言版）
顺序表
weixin_34355881的博客
04-06 155
一、数据是如何在内存中存储的？ 32位系统中char，int型数据在内存中的存储方式： char占1byte（8bit） int占4byte（32bit） 假设我们有一个int类型的值，它从0x01开始，一个int占据4个字节，则其结束于0x04。 二、数据类型有什么意义？ 它确定了一个特定类型的数据到底要申请多大的内存地址来存储数据，并且决定取到的二进制数应该如何解释。 ...
[数据结构]顺序表
Daisy_fight的博客
05-12 2306
#include&lt;stdio.h&gt; #include&lt;conio.h&gt; #include&lt;stdlib.h&gt; #define MAXLEN 100 typedef int DataType; typedef struct { DataType Data[MAXLEN]; int Length; }SeqList; SeqList L; void In...
考研数据结构：顺序表操作与去重算法详解
本资源是一份针对考研数据结构算法的代码总结，主要涵盖顺序表的操作。顺序表是一种线性数据结构，其特点是元素按照一定的顺序存储，易于进行插入、删除和查找操作。以下是对文件中几个关键知识点的详细解析： 1. *...
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
数据结构教程详解：顺序表！理论思路+【学生信息管理系统】代码实操，80分钟带你学会顺序存储结构！
12-30
数据结构是计算机科学中非常重要的概念，它用于组织和存储数据，以便能够高效地访问和操作数据。在Python中，有四种内建的数据结构：List（列表）、Tuple（元组）、Dictionary（字典）和Set（集合）。每种数据结构都...
C语言实现顺序表数据结构：插入与删除算法详解
"该资源是关于数据结构中顺序表的插入与删除操作的C语言实现，适用于配合《数据结构（C语言版）》教材学习。它定义了一个名为SqList的结构体来存储顺序表，包括元素数组、当前长度和数组总大小。提供了InitList_Sq...
数据结构---顺序表
blue_jun_的博客
04-22 1210
1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储元素 2. 动态顺序表：使用动态开辟的数组存储。 由于静态顺序表数组定长，所以存在数组过小不够用，数组过大空间浪费等问题。 所以我们一般使用动态顺序表，接下来我们就讲解一个动态顺序表的实现。 2.动态顺序表的实现 首先，创建一个项目，定义一个头文件“seqlist....
数据结构_顺序表
付某人的博客
09-18 171
实现顺序表的增 删 改 查 插入 修改 package com.Test.Demo.数据结构; import java.util.Scanner; /** * @Author Fu XvZhuang * @Date 2020/9/13 11:32 * @Version 1.0 */ public class 顺序表 { public static void main(String[] args){ Scanner sc = new Scanner(System.in);
数据结构：顺序表
Jags的博客
05-10 1501
一、概述 零个或多个数据元素的有限序列称为线性表。 线性表的特征是在一个序列中，除了头尾元素，每个元素都有且只有一个直接前驱，有且只有一个直接后继，而序列头元素没有直接前驱，序列尾元素没有直接后继。 数据结构中常见的线性表：顺序表、链表（单链表、双链表、循环链表、循环双链表）、栈、队列、字符串… 线性表中的元素为某种相同的抽象数据类型。可以是C语言的内置类型或结构体，也可以是C++自定义类型。 存储方式有 顺序存储结构和链表存储结构 二、线性表的顺序存储结构 线性表的顺序存储结构，指的是用一段地址连续
数据结构【顺序表】
undefined的博客
05-15 421
数据结构中的线性结构及动态顺序表的相关操作
数据结构之顺序表
qq_61688804的博客
06-26 716
程序运行截图： 首先，看到构造方法：add方法：总结，通过上面的源码分析我们可以发现： 并且当放满之后，每一次的扩容都是原来的1.5大小。这个时候就是直接给数组开辟了你指定的大小。除此之外，ArrayList还有一个比较特殊的构造方法，你可以直接传入其他的任何实现了Collection接口的实现类作为参数来进行ArrayList的构造，源码如下： 程序运行截图： 程序运行截图：【为什么用List接收ArrayList引用？】\color{red}{【为什么用List接收ArrayList引用？】}【为什么
数据结构顺序表
travel_dream的博客
04-07 2546
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上(内存中)并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。使用顺序表的原因在于，数
C数据结构-顺序表
qq_43352801的博客
11-02 304
顺序表的增删改查-C语言 文章目录一、顺序表存储结构二、顺序表的表示及初始化1.c语言定义的线性表的顺序存储结构如下2.初始化一个空表二、顺序表的基本运算总结 一、顺序表存储结构 顺序表，即线性表的顺序储存，是指用一组地址连续的存储单元依次存储线性表的各个元素。 下图给出了顺序表的存储结构示意图。由图可知，只要知道第一个元素的地址Loc(a1)，和每个元素所占用字节数k，就可以计算出顺序表中任意一个元素的存储地址，从而实现对数据元素的随机读取。 第i个元素地址计算 Loc(ai)=Loc(a1) 二、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值