顺序表的简单介绍与实现

已于 2023-11-09 10:23:05 修改
阅读量36 收藏
点赞数
文章标签： 数据结构 c语言
于 2023-11-06 16:28:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingyuefenxiang/article/details/134249275
版权

#顺序表# 顺序表

文章目录

一.顺序表简单的说明

  1. 本质：顺序表是通过开辟一个连续的空间来存储数据。即通过数组存储数据。

  2. 特性：2.1 中间/头部的插入删除，时间复杂度为O(N)

    ​ 2.2 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

    ​ 2.3 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，

    ​ 再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

  3. 顺序表的存储结构

    ​ 3.1顺序表静态存储结构

           #define N 7
       typedef int SLdataType;
       typedef struct SeqList
       {
           SLdataType array[N];//创建一个定长数组；
           size_t size;//有效数据个数 ，即数组的下标   
       }SL;

    ​ 静态存储结构数组大小是定值，数据存满后无法扩容。#difine 将标识符 N 的值 定义为7

    ​ typedef 是类型重定义 就是给一个东西取个外号，让这个外号可以被编译器识别

    ​ 3.2顺序表动态存储结构

           typedef int SLdataType;
       typedef struct SeqList
       {
           SLdataType* arrayPointer;//记录数组地址，数组大小可以通过内存函数进行调整.
           size_t size;//有效数据个数 
           size_t capacity;//记录数组的最大容量，通过 与有效数据个数 进行比较 来 判断数组 是否 还有 空间 存储数据
       }SL;

二.动态顺序表的实现

1.动态顺序表的功能

​ 功能包含：1.顺序表的初始化，即

​ 1.1 在栈空间malloc一个数组并将地址信息保存与顺序表结构中。

​ 1.2 将有效数组个数 初始化为0.

​ 1.3 记录数组的最大容量，申请的数组空间所能存储的最大元素个数

​ 2.顺序表空间容量检查： 检查是否还有空间存储数据，不够时进行扩容。

​

​ 3.头插 ：在下标为0的位置插入数据

​ 4.尾插 ： 在下标为 size 的的地方插入数据（size是数组当前的有效数据个数，即当前存储了多少个数，

​ 下标是从0 开始所以比元素个数小1.）

​

​ 5.在指定下标位置插入数据

​

​ 6.头删：将下标为0的位置数据删除

​

​ 7.尾删：将下标为 size 的位置数据删除

​

​ 8.删除指定下标的数据

​

​ 9.查找数据所在下标

​ 10.修改指定位置的数据

​

​ 11.顺序表数数据打印

​

​ 12.顺序表销毁 ： 在栈空间上储存的数据需要手动释放

2.顺序表初始化

void SLInit(SL*ps)
{
    assert(ps);
    ps->arrayPointer=(SLdataType*)malloc(sizeof(SLdataType)*4);//为数组申请4个元素空间
    if(ps->arrayPointer==NULL)
    {
         perror("arrayPointer malloc fail");
         return NULL;
    }
    ps->size=0;
    ps->capacity=4;
    
}

3.顺序表的容量检查

void SLCapacityCheck(SL*ps)
{
    assert(ps);
    if(ps->size==ps->capacity)
    {
        SLdataType*p=(SLdataType*)realloc(ps->arrayPointer,sizeof(SLdataType)*ps->capacity*2);
        if(p==NULL)
        {
            perror("realloc fail");
            return ;
        }
        ps->arrayPointer=p;
        ps->capacity*=2;//最大容量重新记录
    }
   
}

4.头插

void SLPushFront(SL*ps,SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查
    int i=0;
    int size=ps->size;
    for(i=size;i>0;i--)
    {
        ps->arrayPointer[i]= ps->arrayPointer[i-1];
    }
    ps->arrayPointer[0]=x;
    ps->size++;
}//时间复杂度为o(N)

5.尾插

void SLPushBack(SL*ps,SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查
    ps->arrayPointer[ps->size]=x;
    ps->size++;
}//时间复杂度为o(1)

6.在pos位置之前插入数据

void SLInsert(SL*ps,int pos,SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查 
    int moveDataNum=ps->size-1-pos+1;//ps->size是当前存储的元素个数，与下标一起进行计算须先自减1；
    int i=0;
    int size=ps->size;
    for(i=0;i<moveDataNum;i++)//挪数据循环，挪 moveDataNum 次
    {
        ps->arrayPointer[size-i]=ps->arrayPointer[size-i-1];
    }
    ps->arrayPointer[pos]=x;
    ps->size++;
}

7.头删

void SLPopFront(SL*ps)
{
    assert(ps);//指针为空检查
    assert(ps->size);//顺序表为空检查
    int i=0;
    int size=ps->size;
    for(i=1;i<size;i++)//挪数据循环，挪 size-1 次
    {
        ps->arrayPointer[i-1]=ps->arrayPointer[i];//数据覆盖，变相删除
    }
    ps->size--;
}

8.尾删

void SLPopback(SL*ps)
{
    assert(ps);//指针为空检查
    assert(ps->size);//顺序表为空检查
    int i=0;
    int size=ps->size;
    ps->size--;
}

9.删除指定下标的数据

void SLErase(SL*ps,int pos)
{
    assert(ps);//指针为空检查
    assert(ps->size);//顺序表为空检查 
    int moveDataNum=ps->size-1-pos+1;//ps->size是当前存储的元素个数，与下标一起进行计算须先自减1；
    int i=0;
    int size=ps->size;
    for(i=0;i<moveDataNum;i++)//挪数据循环，挪 moveDataNum 次
    {
        ps->arrayPointer[pos+i]=ps->arrayPointer[pos+i+1];
    }
    ps->size--;
}

10.查找数据所在下标

int SLFind(SL*ps,SLdataType x)
{
    assert(ps);//指针为空检查
    int i=0;
    for(i=0;i<ps->size;i++)
    {
        if(ps->arrayPointer[i]==x);
        //printf("第一个值为 %d 的数据下标为 %d\n",x,i);
        return i;
    }
    printf("未发现该数据\n");
    return -1;      
}

11.修改下标为pos位置的数据

void SLModify(SL*ps,int pos,SLdataType x)
{
    assert(ps);
    assert(pos<=ps->size||pos>=0)
    if(pos==ps->size)
    {
        SLPushBack(ps,x);//尾插
        return;
    }
    ps->arrayPointer[pos]=x;
}

12.顺序表数据打印

void SLprint(SL*ps)
{ 
    int i = 0;
    printf("\n          下标:>");
    for (i = 0; i < ps->size; i++)
    {
        printf(" %-3d ", i);
    }
    printf("\n          数据:>");
    for (i = 0; i < ps->size; i++)
    {
        printf(" %-3d ", ps->arrayPointer[i]);
    }
    printf("\n");
}

13.顺序表销毁

void SLDestory(SL*ps)
{
    assert(ps);
    free(ps->arrayPointer);
    ps->arrayPointer=NULL;
    ps->capacity=0;
    ps->size=0;
}

14代码汇总SL.c

#define _CRT_SECURE_NO_WARNINGS
#include"SL.h"
void SLInit(SL* ps)
{
    assert(ps);
    ps->arrayPointer = (SLdataType*)malloc(sizeof(SLdataType) * 4);//为数组申请4个元素空间
    if (ps->arrayPointer == NULL)
    {
        perror("arrayPointer malloc fail");
        return NULL;
    }
    ps->size = 0;
    ps->capacity = 4;

}
void SLCapacityCheck(SL* ps)
{
    assert(ps);
    if (ps->size == ps->capacity)
    {
        SLdataType* p = (SLdataType*)realloc(ps->arrayPointer, sizeof(SLdataType) * ps->capacity * 2);
        if (p == NULL)
        {
            perror("realloc fail");
            return;
        }
        ps->arrayPointer = p;
        ps->capacity *= 2;//最大容量重新记录
    }

}
// 4.头插
void SLPushFront(SL * ps, SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查
    int i = 0;
    int size = ps->size;
    for (i = size; i > 0; i--)
    {
        ps->arrayPointer[i] = ps->arrayPointer[i - 1];
    }
    ps->arrayPointer[0] = x;
    ps->size++;
}//时间复杂度为o(N)


// 5.尾插
void SLPushBack(SL * ps, SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查
    ps->arrayPointer[ps->size] = x;
    ps->size++;
}//时间复杂度为o(1)


// 6.在pos位置之前插入数据
void SLInsert(SL * ps, int pos, SLdataType x)
{
    assert(ps);//指针为空检查
    SLCapacityCheck(ps);//容量检查 
    int moveDataNum = ps->size - 1 - pos + 1;//ps->size是当前存储的元素个数，与下标一起进行计算须先自减1；
    int i = 0;
    int size = ps->size;
    for (i = 0; i < moveDataNum; i++)//挪数据循环，挪 moveDataNum 次
    {
        ps->arrayPointer[size - i] = ps->arrayPointer[size - i - 1];
    }
    ps->arrayPointer[pos] = x;
    ps->size++;
}


// 7.头删
int SLPopFront(SL * ps)
{
    assert(ps);//指针为空检查
    if (ps->size == 0)//顺序表为空检查
    {
        printf("\n顺序表已经删空了\n");
        return 1;
    }
    int i = 0;
    int size = ps->size;
    for (i = 1; i < size; i++)//挪数据循环，挪 size-1 次
    {
        ps->arrayPointer[i - 1] = ps->arrayPointer[i];//数据覆盖，变相删除
    }
    ps->size--;
    return 0;
}


// 8.尾删
int SLPopback(SL * ps)
{
    assert(ps);//指针为空检查
    if (ps->size == 0)//顺序表为空检查
    {
        printf("\n顺序表已经删空了\n");
        return 1;
    }
    int i = 0;
    int size = ps->size;
    ps->size--;
}


// 9.删除指定下标的数据
void SLErase(SL * ps, int pos)
{
    assert(ps);//指针为空检查
    assert(ps->size);//顺序表为空检查 
    int moveDataNum = ps->size - 1 - pos + 1;//ps->size是当前存储的元素个数，与下标一起进行计算须先自减1；
    int i = 0;
    int size = ps->size;
    for (i = 0; i < moveDataNum; i++)//挪数据循环，挪 moveDataNum 次
    {
        ps->arrayPointer[pos + i] = ps->arrayPointer[pos + i + 1];
    }
    ps->size--;
}


// 10.查找数据所在下标
int SLFind(SL * ps, SLdataType x)
{
    assert(ps);//指针为空检查
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (ps->arrayPointer[i] == x)
        {
            printf("第一个值为 %d 的数据的下标为 %d\n", x, i);
            return i;
        }
    }
    printf("未发现该数据\n");
    return -1;
}


// 11.修改下标为pos位置的数据
void SLModify(SL * ps, int pos, SLdataType x)
{
    assert(ps);
    assert(pos <= ps->size || pos >= 0);
    if (pos == ps->size)
    {
          SLPushBack(ps, x);//尾插
          return;
    }
    ps->arrayPointer[pos] = x;
}




//12.顺序表数据打印
void SLprint(SL * ps)
{
    int i = 0;
    printf("\n          下标:>");
    for (i = 0; i < ps->size; i++)
    {
        printf(" %-3d ", i);
    }
    printf("\n          数据:>");
    for (i = 0; i < ps->size; i++)
    {
        printf(" %-3d ", ps->arrayPointer[i]);
    }
    printf("\n");
}


// 13.顺序表销毁
void SLDestory(SL * ps)
{
    assert(ps);
    free(ps->arrayPointer);
    ps->arrayPointer = NULL;
    ps->capacity = 0;
}

15测试代码text.c

#define _CRT_SECURE_NO_WARNINGS
#include"SL.h"
int main()
{
	SL s;
	SLInit(&s);
	SLPopFront(&s);
	SLPopback(&s);
	SLPushFront(&s, 1);
	SLPushFront(&s, 2);
	SLPushFront(&s, 3);
	SLPushFront(&s, 4);
	SLPushFront(&s, 5);
	SLPushBack(&s, 6);
	SLPushBack(&s, 7);
	SLPushBack(&s, 8);
	SLPushBack(&s, 9);
	SLPushBack(&s, 10);
	SLprint(&s);
	int pos = SLFind(&s, 10);
	SLModify(&s, pos, 20);
	SLModify(&s, --pos, 20);
	SLInsert(&s, pos, 100);
	SLErase(&s, 4);
	SLprint(&s);

	SLDestory(&s);
	return 0;
}

16运行截图

在这里插入图片描述

影月焚香
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
顺序表的简单实现(C语言)
文溪山人的博客
03-11 7129
数据结构顺序表静态与动态代码实现
顺序表(数组)实现
hxy1625309592的博客
12-15 3315
1.1 基本介绍 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 数组是最常见的顺序表，数组(Array)是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。 1.2 相关原理分析 1、基本概念 数组用一组连续的内存空间来存储一组具有相同类型的
C语言实现顺序表与链表创建
个人学习笔记库，一篇一篇记录成长的足迹
06-13 2912
使用指正作为形参时，传递的是实参的地址，对地址的操作会改变实参的值，因此指针作为参数函数的执行会改变实参的值。变量是用来信息的，语言间信息分成了若干类即基本数据类型，如int，float，long等，但是这些只能存储一个信息，对于某一类信息的集合无法存储，于是有了数组的数据类型，用于存储同一类型的变量。数组的本质也是一个数据类型，只不过会存错多个变量的值。非常关键，执行该程序使的head重新指向新的地址，实际上头结点head是一个逻辑上的头结点，依次移想新结点地址，而原地址就为存放结点信息的链表结点。
掌握顺序表：从概念到C语言实现
热门推荐
howard2005的专栏
01-16 2万+
C语言实现顺序表的创建与增删改查操作
顺序表的简单实现
m0_57249790的博客
03-30 2563
简介 虽说名叫顺序表，但其中的内容跟上篇的通讯录如出一辙，只不过略有不同的是这个顺序表定义的函数名遵循STL，而且只传入了整型的数据并没有像通讯录中的字符型那种。 1、定义一个SeqList结构体 结构体中需要存放的是指针a 当前有效数据size 容量 capacity 代码如下： typedef int SLDateType;//这样可以简单的控制存入数据的类型 //定义一个SeqList 结构体 来存放 a size capacity 变量 typedef struct SeqList {
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2182
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
Java实现顺序表
weixin_64448174的博客
05-12 6023
目录 一、顺序表的简单理解 1、为什么我们要以数组为基础来构建顺序表呢？ 2、顺序表都具有哪些功能 二、顺序表的代码实现 1、构建并且初始化顺序表 2、在顺序表中添加元素 1、判断需要添加元素的下标是否在顺序表的范围内 2、如果添加元素下标合法，进行添加元素操作。 3、判断顺序表是否满了满了的话我们需要进行扩容 4、实现代码如下： 3、打印顺序表中的元素 4、判断顺序表中是否含有某个元素 5、查找顺序表中元素的下标 6、更新顺序表对应下标的元素值 7、查找顺序表对应下标的元
顺序表C语言实现详解
hurryddd
04-03 3027
1、线性表 线性表。全名为线性存储结构，可以理解为即“把所有数据用一根线儿串起来，再存储到物理空间中”。线性表并不是一种具体的存储结构，它包含 顺序存储结构 和 链式存储结构，是顺序表和链表的统称。除了数组，链表、队列、栈等也是线性表结构。 顺序存储结构：将数据依次存储在连续的整块物理空间中 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系 非线性表。在非线性表中，数据之间并不是简单的前后关系。比如树、图 2、顺序表 它用一组连续的内存空间，来存储一组具有
顺序表与链表的异同
xlsj雪松的博客
10-12 3221
一、空间 1) 创建 ① 顺序表：静态创建一块连续的空间。 ② 链表：动态的创建不连续的空间。 2）使用 ① 顺序表： 优点： 按逻辑顺序连续存储，提高空间利用率； ...
C实现顺序表
鸽子的博客
08-04 3288
1. 实验目的 （1）掌握线性表的顺序存储结构； （2）验证顺序表及其基本操作的实现； （3）理解算法与程序的关系，能够将顺序表算法转换为对应的程序。 2. 实验内容 （1）建立含有若干个元素的顺序表； （2）对已建立的顺序表实现插入、删除、查找等基本操作。 3. 实验提示 定义顺序表的数据类型——顺序表结构体SeqList，在SeqList基础上实现题目要求的插入...
数据结构顺序表，c语言简单实现
01-12
顺序表是一种基本的数据结构，它的实现简单直观，适用于小规模数据的存储。本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过...
python实现顺序表的简单代码
09-20
主要为大家详细介绍了顺序表定义及python实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
使用顺序表实现奇偶排序
09-25
为了实现奇偶排序，我们创建了两个新的动态数组`arr1`和`arr2`，它们的大小与原顺序表相同，因此空间复杂度为O(n)。 **代码实现**： 在提供的代码中，定义了一个顺序表结构`SqList`，包含了数组`data`和长度`length...
用C++实现简单的顺序表
12-27
本文将深入探讨如何用C++语言实现一个简单的顺序表，并介绍其相关功能。C++是一种强大的编程语言，它提供了丰富的特性来支持面向对象编程，使得实现数据结构变得高效且易于理解。 顺序表在内存中以数组的形式存储...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 106
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 656
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 193
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1228
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
数据结构---二叉树
weixin_47808575的博客
07-22 272
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
顺序表销毁与操作实现详解
作者吕鹏泽使用C语言实现了动态顺序表的12个基本操作，如初始化、销毁、清空等，以及两个附加功能（保存和加载数据）和一个简单的菜单框架。程序设计注重灵活性，例如： 1. 顺序存储结构部分，作者重点展示了如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值