【数据结构学习记录2】—— 线性表之顺序储存（顺序表）

最新推荐文章于 2023-04-14 17:56:43 发布
最新推荐文章于 2023-04-14 17:56:43 发布
阅读量1.2k 收藏 6
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 c语言 c 链表 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011017694/article/details/109196934
版权

顺序表

零.前言

这内容可能和书上的代码不一样，因为我是加入了我的理解的，所以可能会有不合理的地方，如果出现问题，可以请大家斧正QAQ

一.原理

1.简述

一个数组是最简单的线性顺序储存结构，但是，当我们的数据成员比较多的时候，比如一个学生类型的数据结构，会有他的姓名、学号等信息，所以我们需要对这部分自定义一个结构体。当然，使用结构体数组就可以完成这个目的——把学生类组成一张线性表。
但是对于一个不定长的表，我们使用结构体数组的话，我们如果不能很好的预估长度的话，可能会浪费空间或者造成越界访问。
所以我们可以自己写一个顺序表，使用malloc来动态创建一个表。

2.分析

我们要实现一个表结构，我们肯定要存在以下几个函数：

  1. 表的初始化(创建)
  2. 表的销毁(节约空间)
  3. 插入(增)
  4. 删除(删)
  5. 修改(改)
  6. 查询(查)

3.思路图解

为了实现以上提到的几个函数，我们可以先大概考虑一下构建的思路：

1.3.0 初始化之前的思考

对于我们创建一个表，肯定我们先要创建一个表的基本储存元素：
在这里插入图片描述

1.3.1 表的创建

我们可以通过再创建一个结构体来作为我们表的结构，其中我们把它分为三块：

  1. 学生类型的储存空间。通过malloc来创建一堆空间来储存，这个空间的首地址，就是我们学生类的开始地址。
  2. 一个整型变量，用于存放当前已经存放了多少个“学生”
  3. 一个整型变量，用于知道我们目前最大能存多少个“学生”
    我们结束地址的值实际上指向的是我们“可以使用”的第一个值，这个值我们一般称为尾后
    所以 这个表看起来像这样：
    在这里插入图片描述

1.3.2 销毁

我们可以对储存空间使用free函数，这样，这个空间就会被销毁了。

1.3.3 插入

假设我们要向序号1插入一个节点，那么我们就把序号1及其以后的节点都依次往后移动一个位置，然后序号1的节点就空出来了，这样就可以把我们要插入位置的节点空出来，这样在把值赋值进去就行了。

在这里插入图片描述

1.3.4 删除

对于删除一个节点，我们只需要将删除的那个节点后面至结束的所有节点向前移动一个位置
，就可以了！
在这里插入图片描述

1.3.5 查找

对于查，我们可以从头到尾遍历一遍就可以查出某个值了。

二.代码实现

1.定义些常量

#define OK      1
#define ERROR   0
#define LIST_DEFAULT_LEN    50
#define LIST_NEW_LEN        8

2.定义节点(元素)

typedef struct elemType {
    int id;
    int sex;
}elemType;

为什么要这样写？
如果使用这种写法：

struct elemType {
    int id;
    int sex;
};

你只是申明了结构体elemType，如果要使用它作为类型，申请其他变量，还是需要：struct elemType name1；
如果使用这种：

struct elemType {
    int id;
    int sex;
}name;

那么你还只是申明了结构体elemType和一个该类型的变量name，如果要使用它作为类型，申请其他变量，还是需要：struct elemType name1；
而我们使用的这种方法：

typedef struct elemType {
    int id;
    int sex;
}elemType;

是创建了一个结构体elemType，并将这个结构体定义成elemType类型，以后申明变量就可以直接elemType name了

3.定义顺序表

typedef struct listType {
    elemType *data;
    int len;
    int MAX_LEN;
}listType;

4.创建函数

首先我们用malloc申请LIST_DEFAULT_LEN个elemType的储存空间。
然后再判断是否申请成功，并完成初始化。
提一句，按书上写的应该是int InitList(listType &list)，但是标准的C语言是不允许在函数里传递引用的，所以我们只能传递指针。如果想用int InitList(listType &list)方式，那就得使用C++
对于取指针指向元素的成员值应该用->
若想用.，需要先解指针：
listType llist = *list;
然后就可以llst.data了

int InitList(listType *list)
{
    list->data = (elemType *)malloc(LIST_DEFAULT_LEN * sizeof(elemType));
    if (list->data <= 0)
    {
        exit(1);
    }
    else
    {
        list->len = 0;
        list->MAX_LEN = LIST_DEFAULT_LEN;
    }
    
    return OK;
}

5.销毁函数

直接free掉申请的顺序表元素的储存空间

int DestroyList(listType *list)
{
    free(&list->data);
    list->len = -1;
    list->MAX_LEN = -1;
}

6.查看函数

写这个函数的目的就是为了像这样，查看目前表的结构。
在这里插入图片描述
先判断一下这个表是否存在，如果存在我们用一个for把0~len - 1的所有元素数据输出来即可。

int ShowList(listType *list)
{
    int i = 0;

    if (list->MAX_LEN <= 0)
    {
        return ERROR;
    }
    else
    {
        for (i = 0; i < list->len; ++i)
        {
            printf("No.%d id=%d sex=%d\n", i, list->data[i].id, list->data[i].sex);
        }
    }

    return OK;
}

7.插入函数

int InsertElem(listType *list, int index, elemType elem)
{
    int i = 0;

    if (index > list->MAX_LEN || index < 0)
    {
        return ERROR;
    }
    else if (list->len < index)
    {
        index = list->len;
    }
    else
    {
        for (i = list->len; i > index; --i)
        {
            list->data[i] = list->data[i-1];
        }
    }
    
    list->data[index] = elem;
    
    if (list->len >= list->MAX_LEN)
    {
        list->data = (elemType *)realloc(&list->data, (list->MAX_LEN + LIST_NEW_LEN) * sizeof(elemType));
    }
    
    ++list->len;

    return OK;
}

我们分块儿来看：

    if (index > list->MAX_LEN || index < 0)
    {
        return ERROR;
    }
    else if (list->len < index)
    {
        index = list->len;
    }
    else
    {
        for (i = list->len; i > index; --i)
        {
            list->data[i] = list->data[i-1];
        }
    }

这一组，我们是先判断:
如果插入的位置，大于了最大的长度或者小于0，那么输入肯定无效。
如果比len大但小于最大长度，那么我们就把index等于len的值，也就是插入到末尾。
如果len在已有的数据的表内。那么我们把len 到 index + 1的所有值，都赋值为它前面的那个值。需要从大到小进行遍历，因为是往后，如果从小开始，后面的值就会被覆盖。

list->data[index] = elem;

然后对其他的元素操作好了之后，data[index]这个地方的值已经可以使用了，我们赋值即可。

    if (list->len >= list->MAX_LEN)
    {
        list->data = (elemType *)realloc(&list->data, (list->MAX_LEN + LIST_NEW_LEN) * sizeof(elemType));
    }

然后我们看看现在len是否已经达到了最大的长度，如果达到了，我们就再多申请几个位置，为下一次赋值做好准备。这样，就不需要在每次操作之前，对长度的合法性进行校验，毕竟我们时刻准备着存储数据。预处理一般总是比临时处理好很多。

++list->len;

然后，我们的len应该是指向我们能用的元素，也就是最后一个元素的下一个位置，所以需要+1

8.删除函数

删除函数就比较简单了，只要参数合法，直接向前移动一个位置即可。
所以我们直接将len-1，然后判断修改合法性，再依次向前移动。

int DeletElem(listType *list, int index)
{
    int i = 0;
    
    list->len -= 1;
    
    if (index < 0 || index > list->MAX_LEN)
    {
        return ERROR;
    }
    else if(index > list->len)
    {
        index = list->len;
    }

    for (i = index; i < list->len; ++i)
    {
        list->data[i] = list->data[i + 1];
    }

    return OK;
}

9.查询函数

参数填要查询的值，若非关键字，就填-1，然后遍历一下表，并查询复合要求的数，一旦达到目标返回它的索引值index，找不到就返回-1

int QueryElem(listType *list, int id, int sex)
{
    int i = 0;
    int mark = 0;

    for (i = 0; i < list->len; ++i)
    {
        mark = 0;
        if (id == -1 || id == list->data[i].id)
        {
            ++mark;
        }
        if (sex == -1 || sex == list->data[i].sex)
        {
            ++mark;
        }
        if (mark == 2)
        {
            return i;
        }
    }

    return -1;
}

三.测试

我们写个主函数，并看看效果：

int main()
{
    listType list;
    elemType elem;

    elem.id = 456;
    elem.sex = 1;

    InitList(&list);
    InsertElem(&list, 0, elem);
    elem.id = 123;
    InsertElem(&list, 0, elem);
    elem.id = 789;
    InsertElem(&list, 7, elem);
    elem.id = 666;
    InsertElem(&list, 8, elem);
    ShowList(&list);
    DeletElem(&list, 3);
    printf("-------\n");
    ShowList(&list);
    printf("index is %d", QueryElem(&list, 456, -1));
    
    return 0;
}

在这里插入图片描述
完美！

四.后记

我不贴完整的代码，免得伸手党白x。
如果是真的仔细看了文章，可以手动复制创建程序。
如果要完整的代码，我贴个下载地址，关注我后，就可以免费下载。
下载地址：https://download.csdn.net/download/u011017694/13001582

ps 好吧，垃—圾CSDN，就算关注了免费下载，也还要做任务才能下载，佛了。直接贴这里吧

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

#define OK      1
#define ERROR   0
#define LIST_DEFAULT_LEN    50
#define LIST_NEW_LEN        8

typedef struct elemType {
    int id;
    int sex;
}elemType;

typedef struct listType {
    elemType *data;
    int len;
    int MAX_LEN;
}listType;

int InitList(listType *list);
int DestroyList(listType *list);
int ShowList(listType *list);
int InsertElem(listType *list, int index, elemType elem);
int DeletElem(listType *list, int index);
int QueryElem(listType *list, int id, int sex);

int main()
{
    listType list;
    elemType elem;

    elem.id = 456;
    elem.sex = 1;

    InitList(&list);
    InsertElem(&list, 0, elem);
    elem.id = 123;
    InsertElem(&list, 0, elem);
    elem.id = 789;
    InsertElem(&list, 7, elem);
    elem.id = 666;
    InsertElem(&list, 8, elem);
    ShowList(&list);
    DeletElem(&list, 3);
    printf("-------\n");
    ShowList(&list);
    printf("index is %d", QueryElem(&list, 456, -1));
    
    return 0;
}

int InitList(listType *list)
{
    list->data = (elemType *)malloc(LIST_DEFAULT_LEN * sizeof(elemType));
    if (list->data <= 0)
    {
        exit(1);
    }
    else
    {
        list->len = 0;
        list->MAX_LEN = LIST_DEFAULT_LEN;
    }
    
    return OK;
}

int DestroyList(listType *list)
{
    free(&list->data);
    list->len = -1;
    list->MAX_LEN = -1;
}

int ShowList(listType *list)
{
    int i = 0;

    if (list->MAX_LEN <= 0)
    {
        return ERROR;
    }
    else
    {
        for (i = 0; i < list->len; ++i)
        {
            printf("No.%d id=%d sex=%d\n", i, list->data[i].id, list->data[i].sex);
        }
    }
    
    return OK;
}

int InsertElem(listType *list, int index, elemType elem)
{
    int i = 0;

    if (index > list->MAX_LEN || index < 0)
    {
        return ERROR;
    }
    else if (list->len < index)
    {
        index = list->len;
    }
    else
    {
        for (i = list->len; i > index; --i)
        {
            list->data[i] = list->data[i-1];
        }
    }
    
    list->data[index] = elem;

    if (list->len >= list->MAX_LEN)
    {
        list->data = (elemType *)realloc(&list->data, (list->MAX_LEN + LIST_NEW_LEN) * sizeof(elemType));
    }

    ++list->len;

    return OK;
}

int DeletElem(listType *list, int index)
{
    int i = 0;
    
    list->len -= 1;
    
    if (index < 0 || index > list->MAX_LEN)
    {
        return ERROR;
    }
    else if(index > list->len)
    {
        index = list->len;
    }

    for (i = index; i < list->len; ++i)
    {
        list->data[i] = list->data[i + 1];
    }

    return OK;
}

int QueryElem(listType *list, int id, int sex)
{
    int i = 0;
    int mark = 0;

    for (i = 0; i < list->len; ++i)
    {
        mark = 0;
        if (id == -1 || id == list->data[i].id)
        {
            ++mark;
        }
        if (sex == -1 || sex == list->data[i].sex)
        {
            ++mark;
        }
        if (mark == 2)
        {
            return i;
        }
    }

    return -1;
}
康娜喵
关注
专栏目录
C++编程练习(1)----“实现简单的线性表的顺序存储结构“
oohaha_123的专栏
03-25 1128
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 故可以用数组来实现顺序存储结构。 用C++编写的利用数组实现简单的读取、插入和删除功能的线性表。 #include #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define TURE 1 #define FALSE 0 typedef int Status;
数据结构（一）——线性表的顺序存储原理及实现
hml111666的博客
02-09 2708
一、线性表介绍 1、定义：由n（n>0）个相同类型的元素组成的有序集合，如图 这里所说的线性表是逻辑结构，表示元素一对一的相邻关系，是独立于存储结构（顺序表和链表）的，他们属于不同层面的概念 2、特点： ➢表中元素的个数是有限的。 ➢表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间 ➢表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序 3、实现方式——顺序表及链表 3.1顺序表：线性表的顺序表示 逻辑上相邻的两个元素在物理位置上也相邻 以上代码描述：.
数据结构（3）之线性表之顺序存储结构
Developer_Zhang的专栏
09-24 3284
1 前言 经过前两张的理论基础，我相信大家都能简单的明白了数据结构和算法一些常用的概念了，从今天开始我们开始学习数据结构中线性表，一些叩响数据结构的大门。 2 详述 线性表（List）:零个或者多个数据元素的有限序列。 如果用数学语言来进行定义： （声明：由于下标不是很好弄出来，所以只能表示下面这种方式了，请见谅！） 若线性表记作(a1,...ai-1,ai,ai+1,...,an)，
数据结构--线性表顺序存储
m0_62476845的博客
09-27 1788
线性表是最简单、最常用的线性结构，有两端，一个是首端，另一个是尾端，除了首尾，数据元素“一个接一个地排列”，并且元素的类型是相同的。//定义一个整型的数据类型//一、存放数据为数组类型int Len;//二\定义长度}List;//结构的名称为List顺序存储表可以随机存取表中的任一元素，其存储位置可以用一个简单的、直观的公式表示。另一方面，这个特点也造成了这种存储结构的缺点：在表中插入和删除操作时，需要移动大量元素。
数据结构--线性表(1)--顺序存储篇
smilejianyue的博客
05-29 1248
线性表是最常见且简单的的一种线性结构。 由n个（n为线性表的长度，当n=0时，线性表为空表）数据特性相同的元素构成的有限序列称为线性表。对于非空线性表或者线性结构，其特点有： ** 1）.表中数据元素个数有限，数据类型同类，有先后次序。 2）.表中都是数据元素，每个元素都是单个元素。 3）. 除第一个数据元素外，其余元素都有前驱 4）. 除最后一个数据元素外，其余元素都有后继 （前驱和后继：比如排队，在你前面的就可以称为前驱，在你后面的，称为后继）**InitList(&L)：初始化线性表，构造一个空线性表
线性表的顺序存储结构
weixin_45564816的博客
04-03 9587
线性表的基本概念 线性结构习惯称为线性表，线性表是n(n>=0)个数据元素构成的有限序列，表中除第一个元素外的每一个元素，有且只有一个一个前件；除最后一个元素外，有且只有一个后件。 非空数据表具有： 只有一个根节点，首元素无前件 有且只有一个终端节点，末尾元素无后件 除收尾节点外，其他所有节点有且只有一个前件和一个后件 线性表的顺序存储结构 通常，线性表可以采用顺序存储和链式存储两种存储结构 顺序存储是存储线性表最简单的结构，具体做法是将线性表中的元素一个接一个地存储在一片相邻的存储区域中。这种顺
数据结构算法代码实现——线性表的顺序表示与实现（二） 定义线性表节点的结构.pdf
04-18
数据结构算法代码实现——线性表的顺序表示与实现（二）定义线性表节点的结构 本资源主要介绍了数据结构中线性表的顺序表示和实现，包括线性表的定义、顺序存储结构、基本操作等内容。 线性表的定义 线性表是一种...
数据结构——线性表之顺序表
weixin_68153081的博客
09-04 1925
数据结构——线性表之顺序表
数据结构第二章 ——线性表之顺序表
weixin_56727133的博客
06-13 400
顺序表的一些基本操作
数据结构基础——线性表之顺序表的插入删除查找操作（附C语言代码）
最新发布
qq_62316014的博客
04-14 2098
本文阐述了顺序表的一些基本操作——插入删除查找，并附上C语言代码。
线性表的顺序存储 增删改查功能
03-16
线性表的顺序存储 增删改查功能 dos窗口输入输出
数据结构与算法——线性表的顺序储存结构
xzt12138的博客
07-20 7060
顺序储存结构就是在内存中找了一块地，将一组数据以连续的方式将其储存在这块内存中。而且每个元素的数据类型相同，所以我们可以用C语言的一维数组来实现顺序储存结构。即，把第一个数据元素存到下标为0的位置，接着把线性表相邻的元素储存在数组中相邻的位置。......
用线性表中的顺序存储结构实现学生信息的基本操作，如：查找、删除、添加学生信息代码（严蔚敏 数据结构）
m0_63543418的博客
05-16 2898
用线性表中的顺序存储结构实现学生信息的基本操作，如：查找、删除、添加学生信息代码（严蔚敏 数据结构）
[数据结构]1.线性表的顺序存储结构——顺序表
qq_44100418的博客
12-11 789
[数据结构]1.顺序表 1.定义数组a[]大小MaxSize，创建数据结构SqList #include <iostream> #include <stdio.h> /* 定义数组大小最大长度 MaxSize */ #define MaxSize 50 typedef int ElemType; /* 创建数据结构 */ typedef struct { Ele...
线性表的顺序存储表示
qq_40835864的博客
12-07 884
线性表的顺序存储表示
线性表--顺序储存结构
Neil
12-30 780
我意识到数据结构的重要性了，决定把把各种类型写一遍，熟练一下，我觉得对这些应该达到了如指掌的地步，才算可以... ////////线性表   顺序储存 ////////code by Apan #include using namespace std; ////////定义线性表
数据结构一一线性表的顺序存储结构之查找操作
xuanyin235的专栏
12-25 1275
1.根据位置查找对应元素 int GetElem(SqList L,int i,ElemType* e) { if (L.iLength==0 || iL.iLength) { return ERROR; } *e = L.iData[i-1]; return OK; } 2.根据元素查找对应位置 int LocateElem(SqList L,ElemType e) { i
线性表（用数组存储数据）
Tony的攻城学习笔记
01-31 1051
线性表是按顺序存储数据时常用的一种数据结构。例如，学生的列表、空房间的列表、城市的列表以及书籍的列表。使用数组存储线性表的元素是实现线性表的其中一种方式。 下面以袋集合为例，介绍数组线性表。袋可以定义为一种没有按照任何特定位置关系来组织其元素的组合。从概念上讲，它类似于放置物品的真实袋子。一旦将元素放入袋中，将不能确定袋中元素的相对位置。如果进入袋中盲目地取出一个元素，则元素的取出几率是相同的。...
数据结构与算法——线性表顺序存储结构
CreativeBoy的专栏
05-05 1117
今天总结一下数据结构中的线性表中的顺序存储结构，这是一种比较简单的结构。  首先，看一下什么是线性表。  什么是线性表？   线性表是一种简单的数据结构，数据元素之间是一对一的关系，即除了第一个和最后一个元素外其余元素都是首尾相接的。元素的个数称为线性表的长度，长度为零则表示线性表为空。   什么是线性表的循序存储结构？   线性表中的顺序存储结构就是把线性表中的元素按逻辑次
广东东软学院：数据结构与算法实验一——线性表顺序存储与栈队列应用
实验课程名称为“数据结构与算法”，聚焦于数据结构中的核心概念——线性表。实验一的具体主题是线性表的顺序存储与链式存储，以及与之相关的栈和队列。实验旨在让学生深刻理解这些数据结构的基础知识，并将其应用到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

康娜喵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值