【数据结构】线性表之顺序表的实现

已于 2023-09-01 17:53:28 修改
阅读量190 收藏 14
点赞数 16
分类专栏： 《数据结构&算法》 文章标签： 数据结构 c语言
于 2023-09-01 17:52:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HZ_ENG/article/details/132617197
版权

                                

目录

   顺序表的概念及结构

   顺序表的实现

初始化顺序表

顺序表的增加

尾插

头插

顺序表的删除

尾删

头删

销毁顺序表

顺序表查找

在pos位置插入元素

在pos位置删除元素

说明

整合源代码

   顺序表的概念及结构

             顺序表：指的是用一组地址连续的存储单元依次存储线性表的数据元素。一般情况下采            用数组存储，在数组上完成数据的增删查改。

             顺序表一般可以分为静态顺序表和动态顺序表

              静态顺序表---使用定长数组存储元素。分配的空间长度是固定的，表一旦空间不足时不            能扩充。

        存储结构类型定义：

              

       动态顺序表---使用动态开辟的数组存储。分配的空间长度大小是可变的，当空间不足时可进行再次分配，即可自由扩充空间大小。

存储类型定义：

          

       静态顺序表只适用于确定知道需要存多少数据的场景，静态顺序表的定长数组分配的空间长度是固定的，不能自由扩充，可能存在浪费或不够用。因此，现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以我们实现动态顺序表。

顺序表的实现

        当在一些大型项目中，分模块进行是比较常见的，因此，顺序表的实现就采用分模块的方式.

  顺序表的实现需要分两个模块：SeqList.h和SeqList.c

SeqList.h       //函数的声明及类型的定义

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

typedef int SLDateType;
//动态顺序表
typedef struct SeqList
{
	SLDateType* a;
	int size;        //当前有效元素的个数
	int capacity;    //当前分配的最大存储容量
}SeqList;


//初始化顺序表
void SeqListInit(SeqList* ps);

//销毁顺序表
void SeqListDestroy(SeqList* ps);

//顺序表的增加
//尾插、尾删
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPopBack(SeqList* ps);

//头插、头删
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);



// 顺序表查找
//找到返回下标、找不到返回-1
int SeqListFind(SeqList* ps, SLDateType x);

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

SeqList.c      //函数的实现

初始化顺序表

      初始化时预先给表分配一些空间

void SeqListInit(SeqList* ps)
{
    assert(ps);  //防止为空指针
    ps->a = (SLDateType*)malloc(sizeof(SLDateType) * 4);//动态开辟数组空间
    if (ps->a == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    ps->size = 0;     //当前有效元素个数初始化为0
    ps->capacity = 4; //当前起始最大限度存储容量先设为4
}

顺序表的增加

     尾插

       此时比较简便，直接在size个元素后插入即可。 但在插入元素当前空间是否已满，此时采用封装一个检查容量并增容的函数，直接调用此函数判断是否空间已满，后面用起来比较方便。

//检查容量并增容
void SLCheckCapacity(SeqList* ps)
{
    assert(ps);
    if (ps->size == ps->capacity)
    {
        SLDateType* pt = (SLDateType*)realloc(ps->a, ps->capacity * 2 * sizeof(SLDateType));
        if (pt == NULL)
        {
            perror("realloc failed");
            exit(-1);
        }
        ps->a = pt;
        ps->capacity *= 2;
    }
}


//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
    SLCheckCapacity(ps);  //判断空间是否满了，若满则扩容
    ps->a[ps->size] = x;  //插入值为x的元素
    ps->size++;           //元素个数加一
}

  头插

     在插入元素之前需要判满。比起尾插较麻烦一些，要从尾部开始size个元素依次往后挪。

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
    assert(ps);
    SLCheckCapacity(ps);//检查容量
    int end = ps->size - 1; //尾元素所在位置
    //后面元素依次向后挪
    while(end >= 0)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    //插入元素
    ps->a[0] = x;
    ps->size++;
}

顺序表的删除

      尾删

     在删除元素之前，需要先判断当前是否为空，这里使用assert来检查，这是一种严格的检查，相比if判断比较暴力，若元素为空直接终止并提示程序异常。if也可判断

//尾删
void SeqListPopBack(SeqList* ps)
{
    assert(ps);
    assert(ps->size > 0); //检查是否为空，为空程序异常报错，这是比较严格的检查；也可用if来判断
    ps->size--;           //元素个数减一
}

    头删

    同样需要先进行检查是否为空，检查方式同上。

//头删
void SeqListPopFront(SeqList* ps)
{
    assert(ps);
    assert(ps->size > 0); //检查是否为空
    int start = 1;  //首元素的位置
    //后面size-1个元素依次向前覆盖
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    //元素个数减一
    ps->size--;
}

销毁顺序表

//顺序表的销毁
void SeqListDestroy(SeqList* ps)
{
    assert(ps);
    free(ps->a);   //释放动态开辟的数组
    ps->a = NULL;
    ps->capacity = ps->size = 0;  
}

顺序表查找

      查找值为x的元素，找到了就返回元素所在的下标，找不到返回-1。

//顺序表的查找
int SeqListFind(SeqList* ps, SLDateType x)
{
    assert(ps);
    int i = 0;
    //查找值为x的元素，找到返回其下标，否则返回-1
    for (i = 0; i < ps->size; i++)
    {
        if (ps->a[i] == x)
            return i;
    }
    return -1;
}

在pos位置插入元素

       

     在插入元素之前，需要检查插入位置是否合法以及当前空间容量。

// 在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
    assert(pos >= 0 && pos <= ps->size); //位置是否合法
    SLCheckCapacity(ps);                 //判断当前容量是否为空
    int end = ps->size - 1;              //尾元素的位置
    //pos位置及其后面的元素依次后挪 
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;       //在插入位置插入元素x
    ps->size++;           //元素个数加一             
}

在pos位置删除元素

       

    同样注意删除前要判断插入位置是否合法

// 在pos位置删除x
void SeqListErase(SeqList* ps, int pos)
{
    assert(pos >= 0 && pos < ps->size); //插入位置是否合法
    int start = pos + 1;                //找到要删除元素位置后一个元素的位置
    //pos位置后面的元素依次向前覆盖
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;     //元素个数减一
}

说明

      前面的头插尾插、头删尾删都可附用以上两段代码，在插入和删除时无伦头插头删、尾插尾删或者只要是插入和删除操作均可，即插入和删除通用代码，用时直接调用即可

整合源代码

//SeqList.h

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

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;        
	int capacity;    
}SeqList;


//初始化顺序表
void SeqListInit(SeqList* ps);

//打印顺序表
void SeqListPrint(SeqList* ps);

//销毁顺序表
void SeqListDestroy(SeqList* ps);

//顺序表的增加
//尾插、尾删
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPopBack(SeqList* ps);

//头插、头删
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);



//SeqList.c

#include "SeqList.h"

void SeqListInit(SeqList* ps)
{
    assert(ps);
    ps->a = (SLDateType*)malloc(sizeof(SLDateType) * 4);
    if (ps->a == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    ps->size = 0;
    ps->capacity = 4;
}


//检查容量并增容
void SLCheckCapacity(SeqList* ps)
{
    assert(ps);
    if (ps->size == ps->capacity)
    {
        SLDateType* pt = (SLDateType*)realloc(ps->a, ps->capacity * 2 * sizeof(SLDateType));
        if (pt == NULL)
        {
            perror("realloc failed");
            exit(-1);
        }
        ps->a = pt;
        ps->capacity *= 2;
    }
}


//顺序表增添数据
//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
    SLCheckCapacity(ps);
    ps->a[ps->size] = x;
    ps->size++;
}

//尾删
void SeqListPopBack(SeqList* ps)
{
    assert(ps);
    assert(ps->size > 0); 
    ps->size--;           
}

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
    assert(ps);
    SLCheckCapacity(ps);
    int end = ps->size - 1;
    while(end >= 0)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}

//头删
void SeqListPopFront(SeqList* ps)
{
    assert(ps);
    assert(ps->size > 0); 
    int start = 1;  
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;
}


//顺序表的销毁
void SeqListDestroy(SeqList* ps)
{
    assert(ps);
    free(ps->a);   
    ps->a = NULL;
    ps->capacity = ps->size = 0;  
}


//顺序表的查找
int SeqListFind(SeqList* ps, SLDateType x)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (ps->a[i] == x)
            return i;
    }
    return -1;
}



// 在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
    assert(pos >= 0 && pos <= ps->size); 
    SLCheckCapacity(ps);                 
    int end = ps->size - 1;              
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;       
    ps->size++;                       
}

// 在pos位置删除x
void SeqListErase(SeqList* ps, int pos)
{
    assert(pos >= 0 && pos < ps->size); 
    int start = pos + 1;               
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;     
}

HZ_ENG
关注
  • 16
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
数据结构之线性表的顺序表示和实现
05-28
以上就是关于“数据结构之线性表的顺序表示和实现”的主要知识点，以及可能的代码实现结构。通过这三个文件，我们可以学习如何在C++中实现一个基本的顺序表，并对其进行操作。这不仅有助于理解数据结构的基础，也为...
数据结构线性表-顺序表（c++、java）.pdf
11-12
在线性表中，元素之间存在一对一的逻辑关系，而顺序表则是将这些逻辑上相邻的元素在内存中也保持相邻，通常通过数组实现。顺序表有静态分配和动态分配两种实现方式。 静态分配的顺序表使用一个预先分配好的定长数组...
线性表之顺序表
03-28
在数据结构的领域里，线性表有多种实现方式，其中顺序表是最简单也是最直观的一种。顺序表是指表中的元素在内存中是连续存放的，就像数组一样，可以通过下标直接访问任意位置的元素。 顺序表的优点在于其访问速度快...
数据结构学习--线性表及其应用--顺序表
06-25
顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种存储方式具有随机访问的优势，因为可以通过元素的索引来直接访问数组中的任意位置。 在顺序表中，主要的操作包括初始...
数据结构_线性表的顺序表示与实现
09-06
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。在线性表中，每个元素都有一个前驱元素和一个后继元素，除了第一个元素没有前驱，最后一个元素没有后继。在实际应用中，...
【归并排序/快排/堆排序】912. 排序数组
m0_63530048的博客
08-07 149
维护大顶堆：从下往上，第一个有孩子节点的节点开始，取根节点、左孩子、右孩子之间的最大值 换到根节点处
单链表-数据结构
qq_31804097的博客
08-07 65
【代码】单链表、双向带头循环链表-数据结构。
数据结构初阶：栈和队列
LCL200356的博客
08-03 814
栈的结构的定义和顺序表结构定义一样，在栈中定义一个指针data用于操作数据，然后定义整型变量capacity用于表示栈的空间大小，最后定义一个整型变量top用于表示有效数据个数也就是我们的栈顶。//定义一个栈的结构//数组//栈的空间的大小int top;//有效数据个数}ST;队列的结点结构就是单链表结点结构，队列结构phead指向头结点和ptail指向尾结点，还有一个size用同统计结点个数。//链式结构表示队列}QNode;//队列结构int size;//计数器。
【数据结构】顺序结构实现：特殊完全二叉树（堆）+堆排序
最新发布
2203_76003626的博客
08-07 846
堆+堆排序
【数据结构-前缀哈希】力扣525. 连续数组
sjsjs11的博客
08-07 67
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
[C++进阶&数据结构]二叉搜索树
2301_80017277的博客
08-07 668
对于二叉树的结点，我们类似于list的结点定义一样，使用一个struct类。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 234
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
【日常开发】 java返回ECharts数据结构封装
边走、边悟、迟早变好
08-07 330
java返回ECharts数据结构封装
数据结构图书管理系统
2305_78057683的博客
08-07 122
数据结构图书管理系统
数据结构 - 相邻节点迭代器
菜鸟小码的博客
08-07 411
在图论中，迭代器是一种常用的工具，用于遍历图中的节点或边。特别是当需要访问一个节点的所有相邻节点时，相邻节点迭代器提供了一种方便且灵活的方式。本文将深入探讨相邻节点迭代器的基本原理，并通过具体的Java代码详细说明如何实现高效的相邻节点迭代器。
【深度学习】P1 深度学习数据结构
weixin_43098506的博客
08-07 519
深度学习的数据结构——张量的概念与其基本操作
【算法模板】数据结构：三分查找
2303_80346267的博客
08-07 306
算法竞赛中的三分（ternary search）是一种用于在单峰函数（unimodal function）上找到最大值或最小值的搜索算法。与二分搜索（binary search）类似，三分搜索在每次迭代中将搜索空间分成三个部分，但三分搜索用于连续区间而不是离散区间。
数据结构第2天作业 8月3日
内啡肽的快乐的博客
08-04 190
创建空的单链表。
数据结构：二叉树
LCL200356的博客
08-07 592
/创建堆结构int size;}HP;
数据结构线性表：顺序表详解
"数据结构线性表(顺序表).ppt" 线性表是数据结构中一种基础且重要的结构，它由n(n≥0)个具有相同特性的数据元素组成的一个有限序列。在线性表中，数据元素按照特定的顺序排列，具有四个主要特性：第一个元素没有...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值