顺序表详解

已于 2022-12-22 21:05:53 修改
阅读量128 收藏
点赞数
分类专栏： 数据结构与算法 --书籍笔记 文章标签： 数据结构
于 2022-12-22 21:00:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62687015/article/details/128402279
版权

何为顺序表？

如果用一组连续的存储单元依次存放线性表中的所有元素，则称该类型的线性表为顺序表。其特点是元素的存储位置与逻辑位置一一对应，因此顺序表通常用数组来表示。

顺序表的定义：

1、静态顺序表：使用定长数组存储元素

  • 缺陷：给小了不够用，给大了可能浪费，非常不实用
#define N 100
typedef int sldatatype;    //后续要存储其它类型时方便更改
typedef struct slNode{
    sldatatype a[N]; //定长顺序表
    size_t len; //顺序表的长度（元素个数）
}seqlist;

2、动态顺序表：使用动态开辟的数组存储元素（以下操作用动态顺序表做）

  • 动态顺序表可根据我们的需要分配空间大小
  • len 表示当前顺序表中已存放的数据个数
  • capacity 表示顺序表总共能够存放的数据个数 
    typedef struct slNode{
    sldatatype *a;  //指向动态开辟的数组
    size_t len;     //数据个数
    size_t capacity;//容量大小
}seqlist；

顺序表的初始化： 

void seqlistInit(seqlist*sl)
{
    assert(sl!=NULL);//断言,防止传进来的指针为空
/*
    if(sl==NULL){
        cout<<"您的顺序表为空"<<endl;
        break;
    };
*/    
    sl->a==NULL; //初始顺序表为空
    sl.len=0;    //初始数据个数为0
    sl.capacity=0;    //初始空间容量为0
}

顺序表的销毁释放：

void seqlistDestroy(seqlist *sl)
{
    assert(sl!=NULL);//断言
    
    free(sl->a);     //释放动态开辟的空间
    sl->a = NULL;    //置空
    sl->len = 0;     
    sl->capacity = 0; 
}

 检查顺序表容量是否已满，进行增容

为什么不采取插一个数据，增容一个空间的方式呢，因为这样也太麻烦了，代价也太大了，一般情况下，为了避免频繁的增容，当空间满了后，我们不会一个一个的去增，而是一次增容 2 倍，当然也不会一次增容太大，比如 3 倍 4 倍，空间可能会浪费，2 倍是一个折中的选择。

void checkCapacity(seqlist *sl)
{
    assert(sl!=NULL);

    if(sl->len==sl->capacity)
    {
        size_t newCapacity;
        if(sl->capacity==0)
            newCapacity = sl->capacity =4;
        else
            newCapacity = sl->capacity * 2;

        //因为sl->a不能直接开辟，因此借助于p进行开辟
        sldatatype *p = (sldatatype *)realloc(sl->a,newCapacity*sizeof(sldatatype));
        if(p==NULL)
        {
            perror("realloc出错");
            exit(-1);
        }
        sl->a = p; //p不为空，开辟成功
        sl->capacity = newcapacity; //更新容量
    }
}

顺序表尾插

void seqlistPushback(seqlist* sl, sldatatype x)
{
    //判断是否为空
    assert(sl != NULL);
    //判断是否容量已满,若满进行开辟
    checkCapacity(sl);

    sl->a[sl->len] = x; //尾插数据
    sl->len++;
}

 顺序表尾删

void seqlistPopback(seqlist *sl)
{
    assert(sl !=NULL);
    assert(sl->len != 0);

    sl->len--; //有效数据-1
    //不知道sldatatype是什么类型的数据，不能冒然的赋值为0
	//psl->a[psl->size - 1] = 0;
}

 顺序表头插

void seqlistPushfront(seqlist* sl , sldatatype x)
{
    assert(sl != NULL);
    checkCapacity(sl);

    //错误代码
    //错误分析，思路：将i位置的值赋给i+1位置的值:。
    //第一次后，i的值假设为5，则i+1的值为5，之后就将5往后传递，从而后面值都为5
    /*int i = 0; 
    for (; i < sl->len; i++)
    {
        sl->a[i + 1] = sl->a[i];
    }*/
    
    int i = 0;
    for (i = sl->len; i > 0; i--) {
        sl->a[i] = sl->a[i - 1];
    }

    sl->a[0] = x;
    sl->len++;      
}

 顺序表头删

void seqlistPopfront1(seqlist* sl) {
    assert(sl != NULL);
    assert(sl->len != 0);

    for (int i = 1; i < sl->len; i++) {
        sl->a[i - 1] = sl->a[i];
    }
    sl->len--;
}

 打印顺序表

void seqlistPrint(const seqlist* sl)
{
    assert(sl != NULL);

    if (sl->len == 0)
    {
        cout << "顺序表为空" << endl;
        return;
    }
    else {
        int i = 0;
        for (; i < sl->len; i++)
        {
            cout << sl->a[i] << endl;
        }
        cout << endl;
        return;
    }
}

 在顺序表中查找指定值

int seqlistFind(const seqlist* sl,sldatatype x)
{
    assert(sl != NULL);

    for (int i = 0; i < sl->len; i++) {
        if (sl->a[i] == x)
            return i;
    }
    return -1;
}

 在顺序表指定下标位置插入数据

void seqlistInsert(seqlist* sl, size_t pos,sldatatype x)
{
    assert(sl!=NULL);  //断言
    assert(pos >0 && pos <= sl->len+1);  //检查pos下标的合法性

    checkCapacity(sl);  //检查顺序表容量是否已满

    size_t i = 0;
    for (i = sl->len; i >= pos; i--)  //将pos位置后面的数据依次向后挪动一位
    {
        sl->a[i] = sl->a[i - 1];
    }
    sl->a[pos-1] = x;  //插入数据
    sl->len++;  //有效数据个数+1
}


//头插改进
void seqlistPushfront2(seqlist* sl,sldatatype x)
{
    seqlistInsert(sl, 1, x);
}

 在顺序表中删除指定下标位置的数据

void seqlistErase(seqlist* sl, size_t pos)
{
    assert(sl);  //断言
    assert(sl->len > 0);  //顺序表不能为空
    assert(pos > 0 && pos <= sl->len);  //检查pos下标的合法性

    size_t i = 0;
    for (i = pos ; i <= sl->len; i++)  //将pos位置后面的数据依次向前挪动一位
    {
        sl->a[i - 1] = sl->a[i];
    }
    sl->len--;  //有效数据个数-1
}

 查看顺序表中有效数据个数

可能大家会有一个疑问，我在主函数里面直接通过定义的结构体变量直接访问就好了呀，为啥还要弄一个函数嘞？

在数据结构中有一个约定，如果要访问或修改数据结构中的数据，不要直接去访问，要去调用它的函数来访问和修改，这样更加规范安全，也更方便检查是否出现了越界等一些错误情况。

但越界不一定报错，系统对越界的检查是一种抽查

  • 越界读一般是检查不出来的

  • 越界写如果是修改到标志位才会检查出来

（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）

size_t seqlistLen(const seqlist* sl)
{
    assert(sl);  //断言

    return sl->len;
}

修改指定下标位置的数据 

void seqlistModify(seqlist* sl, size_t pos, sldatatype x)
{
    assert(sl);  //断言
    assert(sl->len > 0);  //顺序表不能为空
    assert(pos > 0 && pos <= sl->len);  //检查pos下标的合法性

    sl->a[pos-1] = x;  //修改pos下标处对应的数据
}

 完整代码：（vs2022运行成功）

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
#define N 100
typedef int sldatatype;    //后续要存储其它类型时方便更改

typedef struct slNode {
    sldatatype* a;  //指向动态开辟的数组
    size_t len;     //数据个数
    size_t capacity;//容量大小
}seqlist;

//检查顺序表容量是否满了，好进行增容
void checkCapacity(seqlist* sl)
{
    assert(sl != NULL);

    if (sl->len == sl->capacity)
    {
        size_t newCapacity;
        if (sl->capacity == 0)
            newCapacity = sl->capacity = 4;
        else
            newCapacity = sl->capacity * 2;

        //因为sl->a不能直接开辟，因此借助于p进行开辟
        //realloc包含了已有的数据信息，会进行拷贝
        sldatatype* p = (sldatatype*)realloc(sl->a, newCapacity * sizeof(sldatatype)); 
        if (p == NULL)
        {
            perror("realloc出错");
            exit(-1);
        }
        sl->a = p; //p不为空，开辟成功
        sl->capacity = newCapacity; //更新容量
    }
}

//初始化顺序表
void seqlistInit(seqlist* sl)
{
    assert(sl != NULL);//断言,防止传进来的指针为空
/*
    if(sl==NULL){
        cout<<"您的顺序表为空"<<endl;
        break;
    };
*/
    sl->a = NULL; //初始顺序表为空
    sl->len = 0;    //初始数据个数为0
    sl->capacity = 0;    //初始空间容量为0
}

//销毁（释放）顺序表
void seqlistDestroy(seqlist* sl)
{
    assert(sl != NULL);//断言

    free(sl->a);     //释放动态开辟的空间
    sl->a = NULL;    //置空
    sl->len = 0;
    sl->capacity = 0;
}

//顺序表尾插
void seqlistPushback(seqlist* sl, sldatatype x)
{
    //判断是否为空
    assert(sl != NULL);
    //判断是否容量已满,若满进行开辟
    checkCapacity(sl);

    sl->a[sl->len] = x; //尾插数据
    sl->len++;
}

//顺序表打印
void seqlistPrint(const seqlist* sl)
{
    assert(sl != NULL);

    if (sl->len == 0)
    {
        cout << "顺序表为空" << endl;
        return;
    }
    else {
        int i = 0;
        for (; i < sl->len; i++)
        {
            cout << sl->a[i] << endl;
        }
        cout << endl;
        return;
    }
}

//顺序表尾删
void seqlistPopback(seqlist* sl)
{
    assert(sl != NULL);
    assert(sl->len != 0);

    sl->len--; //有效数据-1
    //不知道sldatatype是什么类型的数据，不能冒然的赋值为0
    //psl->a[psl->size - 1] = 0;
}

//顺序表头插1
void seqlistPushfront1(seqlist* sl, sldatatype x)
{
    assert(sl != NULL);
    checkCapacity(sl);

    //错误代码
    //错误分析，思路：将i位置的值赋给i+1位置的值:。
    //第一次后，i的值假设为5，则i+1的值为5，之后就将5往后传递，从而后面值都为5
    /*int i = 0;
    for (; i < sl->len; i++)
    {
        sl->a[i + 1] = sl->a[i];
    }*/

    int i = 0;
    for (i = sl->len; i > 0; i--) {
        sl->a[i] = sl->a[i - 1];
    }

    sl->a[0] = x;
    sl->len++;
}

//顺序表头删1
void seqlistPopfront1(seqlist* sl) {
    assert(sl != NULL);
    assert(sl->len != 0);

    for (int i = 1; i < sl->len; i++) {
        sl->a[i - 1] = sl->a[i];
    }
    sl->len--;
}

//在顺序表中查找指定值，删除指定值，在此基础上进行操作
int seqlistFind(const seqlist* sl, sldatatype x)
{
    assert(sl != NULL);

    for (int i = 0; i < sl->len; i++) {
        if (sl->a[i] == x)
            return i;
    }
    return -1;
}

//在顺序表指定下标位置插入数据，可进行头插和尾插
void seqlistInsert(seqlist* sl, size_t pos, sldatatype x)
{
    assert(sl != NULL);  //断言
    assert(pos > 0 && pos <= sl->len + 1);  //检查pos下标的合法性

    checkCapacity(sl);  //检查顺序表容量是否已满

    size_t i = 0;
    for (i = sl->len; i >= pos; i--)  //将pos位置后面的数据依次向后挪动一位
    {
        sl->a[i] = sl->a[i - 1];
    }
    sl->a[pos - 1] = x;  //插入数据
    sl->len++;  //有效数据个数+1
}

//头插改进2
void seqlistPushfront2(seqlist* sl, sldatatype x)
{
    seqlistInsert(sl, 1, x);
}

//在顺序表中删除指定下标位置的数据
void seqlistErase(seqlist* sl, size_t pos)
{
    assert(sl);  //断言
    assert(sl->len > 0);  //顺序表不能为空
    assert(pos > 0 && pos <= sl->len);  //检查pos下标的合法性

    size_t i = 0;
    for (i = pos; i <= sl->len; i++)  //将pos位置后面的数据依次向前挪动一位
    {
        sl->a[i - 1] = sl->a[i];
    }
    sl->len--;  //有效数据个数-1
}

//顺序表头删2
void seqlistPopfront2(seqlist* sl)
{
    seqlistErase(sl, 0);  //改造头删接口
}

//查看顺序表中有效数据个数
size_t seqlistLen(const seqlist* sl)
{
    assert(sl);  //断言

    return sl->len;
}

//修改指定下标位置的数据
void seqlistModify(seqlist* sl, size_t pos, sldatatype x)
{
    assert(sl);  //断言
    assert(sl->len > 0);  //顺序表不能为空
    assert(pos > 0 && pos <= sl->len);  //检查pos下标的合法性

    sl->a[pos - 1] = x;  //修改pos下标处对应的数据
}


int main()
{
    seqlist s1;
    seqlistInit(&s1);
    //尾插数据
    seqlistPushback(&s1, 5);
    seqlistPushback(&s1, 3);
    seqlistPushback(&s1, 4);
    seqlistPushback(&s1, 6);
    seqlistPushback(&s1, 8);
    seqlistPushback(&s1, 0);
    seqlistPrint(&s1);

    //尾删除
    seqlistPopback(&s1);
    seqlistPrint(&s1);

    //头插
    seqlistPushfront1(&s1, 101);
    seqlistPrint(&s1);

    //头删
    seqlistPopfront1(&s1);
    seqlistPopfront1(&s1);
    seqlistPrint(&s1);

    //查询指定元素
    cout << "查询5元素的位置：" << seqlistFind(&s1, 5) << endl;
    cout << endl;

    //指定位置插入元素
    seqlistInsert(&s1, 3, 666);
    seqlistPrint(&s1);

    //在顺序表中删除指定下标位置的数据
    seqlistErase(&s1, 3);
    seqlistPrint(&s1);

    //查看顺序表中有效数据个数
    cout << "查看顺序表中有效数据个数：" << seqlistLen(&s1) << endl << endl;

    //修改指定下标位置的数据
    seqlistModify(&s1, 2, 999);
    seqlistPrint(&s1);

    //指定位置插入元素，可以进行尾插
    seqlistInsert(&s1, 5, 666);
    seqlistPrint(&s1);
}

参考：

1.(1条消息) C++中的assert用法_喜欢吃冰棍de谷利文君的博客-CSDN博客_c++ assert

2. 大部分以这篇文章为核心，有些小地方进行了改进（基本关于postion的问题）(1条消息) 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）_CodeWinter的博客-CSDN博客_seqlist

3.(1条消息) 动态内存分布——malloc，calloc，realloc，free的使用。以及关于动态内存的常见错误。_我的代码爱吃辣的博客-CSDN博客 

4.(1条消息) c++编程之perror()_kangshuangzhu的博客-CSDN博客_c++ perror 

5.（c++建议还是使用visual studio）vscode配置C/C++环境（超级详细）Day2022/12/02_DreamSuif的博客-CSDN博客_vscode配置c/c++环境 

努力的小羽儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构—顺序表详解
范玖久的博客
04-05 6367
目录 （一）线性表的介绍 （二）顺序表 （一）线性表的介绍 线性表：线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 （1）逻辑上是线性结构，物理...
什么是Python中的顺序表
09-16
**Python中的顺序表详解** 顺序表是数据结构中一种基础且重要的线性结构，它在Python编程中也有广泛的应用。顺序表的特点是逻辑上相邻的元素在计算机内存中存储的位置也是相邻的，这使得访问任意位置的元素变得非常...
数据结构（一）线性结构（1）顺序表
floatinglong的博客
03-11 3704
线性表是最基本、最常用的数据结构，大部分线性表中数据元素之间的关系是一对一的关系，除了首尾元素，其它元素都是首尾相连的 其表示方法主要有顺序表示（顺序表）以及链式表示（链表），在本节介绍顺序表的一些操作实现 顺序表至少包含一个用于存储数据的数组和一个表示数据个数的变量，因此顺序表可定义为： typedef struct { int aiArray[ARRAY_SIZE]; i...
C++实现顺序表的各种基本运算
henry594xiaoli的博客
03-20 2677
领会顺序表存储结构和掌握顺序表中的各种基本运算算法设计 实现顺序表的各种基本运算和整体建表算法（假设顺序表的元素类型 ElemType 为 char）
线性表—顺序表-顺序表基本运算的实现
魂小猫的博客
04-24 1146
基本运算——初始化线性表 lintList 目标是构造出一个空的线性表 分配空间后，将length成员设置为0 对L的作用会传递回去基本运算——销毁线性表 DestroyList C free() C++delete()基本运算——判断是否为空表 ListEmpty bool类型 C没有 C++才有 C自己构造一个基本运算——求线性表长度 ListLength 基
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 5587
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5566
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
顺序表详解（C++实现）
weixin_73567058的博客
12-22 1256
静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大。了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态。用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...2. 动态顺序表：使用动态开辟的数组存储。线性表在物理上存储时，通常以数组和链式结构的形式存储。1. 静态顺序表：使用定长数组存储。的分配空间大小，所以下面我们实现动态顺序表。是线性结构，也就说是连续的一条直线。在数组上完成数据的增删查改。的线性结构，一般情况下采用。
数据结构之顺序表详解
m0_56440500的博客
08-13 1112
顺序表是一种线性表的实现方式，它使用一块连续的内存空间存储元素，并通过下标来访问和操作元素。连续存储：顺序表使用数组来存储元素，数组中的元素在内存中是连续存储的。随机访问：由于元素在内存中连续存储，可以通过下标直接访问任意位置的元素，具有快速的随机访问能力。插入和删除的复杂度较高：在顺序表中插入和删除元素时，需要移动其他元素以保持顺序，因此插入和删除的时间复杂度较高。固定长度：顺序表的长度是固定的，需要预先分配足够的内存空间来存储元素。
数据结构入门 — 顺序表详解
小黄鸭的博客
08-23 2721
顺序表是一种线性表，它的重点是：物理结构：顺序表的数据元素在内存中是连续存放的，即使用一段连续的存储空间来存储线性表的元素。逻辑结构：顺序表是一种线性表，它的元素在逻辑上是依次排列的。数据操作：顺序表支持基本的数据操作，包括插入、删除、查找等操作。其中，插入和删除操作需要移动大量元素，时间复杂度较高，而查找操作可以通过使用二分查找等算法来提高效率。容量管理：顺序表的容量是由数组的长度来决定的。如果数组长度不够，顺序表需要进行扩容操作，如果数组长度过长，会浪费内存空间。
C语言实现静态顺序表的实例详解
08-29
C语言实现静态顺序表的实例详解 在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。...
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
顺序表就地逆置
03-26
### 顺序表就地逆置知识点详解 #### 一、基础知识概述 在计算机科学与技术领域，数据结构作为一门基础且重要的学科，其研究对象主要包括数据的逻辑结构、存储结构以及对这些数据进行操作的算法。其中，顺序表是...
顺序表的基本操作详解.zip
最新发布
03-20
顺序表是一种常见的数据结构，它在计算机科学中扮演着重要的角色。在Python中，我们可以用列表（list）来实现顺序表。...通过阅读"顺序表的基本操作详解.pdf"等文档，你可以更深入地学习顺序表的细节和高级用法。
Python中顺序表原理与实现方法详解
09-18
主要介绍了Python中顺序表原理与实现方法,结合实例形式分析了Python顺序表的概念、原理及增删查等相关实现技巧,需要的朋友可以参考下
顺序表插入删除
11-03
### 顺序表插入删除知识点详解 #### 一、顺序表基本概念 在计算机科学中，顺序表是一种常用的数据结构，其特点是数据元素在内存中连续存放。本实验通过一个简单的C语言程序实现了顺序表的基本操作——插入和删除，...
构造顺序表List
10-25
`Insert` 函数实现了在已排序的顺序表中插入新元素的功能，同时保持顺序表的有序性。该函数接收三个参数：整型数组 `A`、当前数组的实际长度 `n` 和待插入的新元素 `x`。 #### 4.2 插入过程 - **判断位置**：如果...
顺序表的C++程序实现
10-05
### 顺序表的C++程序实现 #### 一、概述 本文将详细介绍如何在C++中使用模板方式来实现顺序表的基本操作，并通过一个具体的示例来演示如何合并两个顺序表。 #### 二、顺序表类的设计与实现 在本节中，我们将深入...
数据结构线性表：顺序表详解
"数据结构线性表(顺序表).ppt" 线性表是数据结构中一种基础且重要的结构，它由n(n≥0)个具有相同特性的数据元素组成的一个有限序列。在线性表中，数据元素按照特定的顺序排列，具有四个主要特性：第一个元素没有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

努力的小羽儿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值