线性表的顺序存储结构

已于 2023-03-19 22:52:03 修改
阅读量272 收藏 2
点赞数 1
分类专栏： 数据结构详解 文章标签： 算法 数据结构
于 2023-03-19 22:49:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haijv/article/details/129658257
版权

文章目录

3.1 线性表的顺序存储结构

3.1.1 顺序存储定义

线性表的顺序存储结构指的是，用一段地址连续的存储单元依次存储线性表的数据元素。

3.1.2 顺序存储方式

顺序存储的代码：

#define MAXSIZE 20              /*定义顺序表的最大容量*/
typedef int ElemType;
typedef struct{
    ElemType data[MAXSIZE];     /*存储数据元素*/
    int length;                  /*线性表当前长度*/
}SqlList;

描述顺序结构需要三个属性：

  • 存储空间的起始位置：数组data，它的存储位置就是存储空间的存储位置。
  • 线性表的最大存储容量：数组长度MAXSIZE。
  • 线性表的当前长度：length。

3.1.3 数组长度与线性表长度的区别

数组的长度：存放线性表的存储空间长度，空间分配后一般不可变

线性表长度：线性表中数据元素的个数，随着线性表的插入和删除操作的进行，这个量是变化的。

注意：在任意时刻线性表的长度 <= 数组长度。

3.1.4 地址计算方法

有线性表a1,a2,a3,···ai,假设每个元素占用的是c个存储单元，则ai的位置用以下方法计算：

LOC(ai)=LOC(a1)+(i-1)*c

通过这个公式，可以随时算出线性表任意位置的地址，不管他是第一个还是最后一个，都是相同的时间。那么我们对每个线性表位置的存入或者取出数据，对于计算机来说都是相等的时间，也就是一个常数，其存取数据的时间复杂度是O(1)，我们通常把具有这一特点的存储结构称为随机存取结构。

3.2 顺序存储结构的插入与删除

3.2.1 获得元素操作

实现GetElem操作，即将线性表第i个位置元素返回，只要i的数值在数组下标范围内，把第i-1下标的值返回即可。代码如下：

/*Status是函数的类型，其值是函数返回结果的状态码，如OK*/
typedef int Status;

/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值，注意i是指位置，第1个位置的数组是从0开始的*/
Status GetElem(SqlList L,int i,ElemType *e){
    if(L.length==0 || i<1 || i>L.length)
        return ERROR;
    *e=L.data[i-1];

    return OK;
}

把指针*e的值给修改成L.data[i-1]，这是真正要返回的数据。

3.2.2 插入操作

我们需要实现ListInsert(L,i,e)，即在线性表L的第i个位置插入新元素e。

插入算法的思路：

  1. 如果插入位置不合理，抛出异常。
  2. 如果线性表长度大于等于数组长度，则抛出异常或动态增加容量。
  3. 从最后一个元素开始向前遍历到第i个位置，分别将他们都向后移动一个位置。
  4. 将要插入的元素填入位置i处。
  5. 表长加1。

代码如下：

/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
Status ListInsert(SqlList *L,int i,ElemType e){
    int k;
    if (L->length==MAXSIZE)                 /*线性表已满*/
        return ERROR;
    if (i<1 || i>L->length+1)                 /*i位置判断，比第一位置小，比最后位置大*/
        return ERROR;
    
    if (i<=L->length){                      /*如果插入位置不在表尾*/
        for(k=L->length-1;k>=i-1;k--)       /*将要插入位置后的元素向后移一位*/
            L->data[k+1]=L->data[k]; 
    }
    L->data[i-1]=e;                         /*将新元素插入*/
    L->length++;                            /*线性表长度加1*/

    return OK;
}

3.2.3 删除操作

我们需要实现ListDelete(&L,i,&e)，将线性表L第i个位置的数据删除，并将其放入指针e中

删除算法的思路：

  1. 如果删除位置不合理，抛出异常。
  2. 取出删除元素。
  3. 从删除元素位置开始遍历到最后一个元素的位置，分别将他们都向前移动一个位置。
  4. 表长减1。

实现代码：

/*初始条件：顺序表L已存在，1<=i<=ListLength*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/
Status ListDelete(SqlList *L,int i,ElemType *e){
    int k;
    if (L->length==MAXSIZE)                  /*线性表已满*/
        return ERROR;
    if (i<1 || i>L->length)                  /*删除位置不正确*/
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length){                        /*如果删除不是最后位置*/
        for(k=i;k<L->length;k++)             /*将删除后继元素前移*/
            L->data[k-1]=L->data[k];       
    }
    L->length--;
    return OK;
}

3.2.4 根据值找位置

实现一个LocacteElem(L,e)，会返回第一个值等于e的元素的位置。

代码如下：

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqlList L,ElemType e){
    int i;
    if (L.length==0){
        return 0;
    }
    for (i=0;i<L.length;i++){
        if (L.data[i]==e){
            break;
        }
    }

    if (i>=L.length)
        return 0;
    
    return i+1;   /*返回该值所在位置*/
}

3.2.4 初始化和遍历线性表

代码如下：

/*初始化线性表*/
Status InitList(SqlList *L){
    L->length=0;
    return OK;
}

/*遍历线性表*/
Status visit(ElemType c){
    printf("%d ",c);
    return OK;
}

Status ListTraverse(SqlList L){
    int i;
    for(i=0;i<L.length;i++){
        visit(L.data[i]);
    }
    printf("\n");
    return OK;
}

3.2.5 将两张表连接

代码如下：

/*将所有的在线性表Lb中但不在La中的数据元素插入到La中*/
void unionL(SqlList *La,SqlList Lb){
    int La_len,Lb_len,i;
	ElemType e;                        /*声明与La和Lb相同的数据元素e*/
	La_len=ListLength(*La);            /*求线性表的长度 */
	Lb_len=ListLength(Lb);

    for(i=1;i<=Lb_len;i++){
        GetElem(Lb,i,&e);               /*将Lb中第i个元素存储到e中*/
        if (!LocateElem(*La,e))         /*如果La中不存在与e相同的数据元素*/
            ListInsert(La,++La_len,e);  
    }
}

3.2.5 测试代码

/*测试代码*/
int main(){
        
    SqlList L;
	SqlList Lb;
    
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);
    i=isEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：L.length=%d\n",L.length);
    i=isEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L); 
    printf("L.length=%d \n",L.length);

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d个元素的值为%d\n",k,j);
            else
                    printf("没有值为%d的元素\n",j);
    }
    

    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 删除第j个数据 */
            if(i==ERROR)
                    printf("删除第%d个数据失败\n",j);
            else
                    printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

	//构造一个有10个数的Lb
	i=InitList(&Lb);
    for(j=6;j<=15;j++)
            i=ListInsert(&Lb,1,j);

	unionL(&L,Lb);

	printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L); 

    system("pause");

    return 0;
}

运行结果：

初始化L后：L.length=0
在L的表头依次插入1～5后：L.data=5 4 3 2 1
L.length=5
L是否空：i=0(1:是 0:否)
清空L后：L.length=0
L是否空：i=1(1:是 0:否)
在L的表尾依次插入1～10后：L.data=1 2 3 4 5 6 7 8 9 10
L.length=10
在L的表头插入0后：L.data=0 1 2 3 4 5 6 7 8 9 10
L.length=11
第5个元素的值为：4
第4个元素的值为3
第5个元素的值为4
删除第12个数据失败
删除第11个的元素值为：10
依次输出L的元素：0 1 2 3 4 5 6 7 8 9
删除第5个的元素值为：4
依次输出L的元素：0 1 2 3 5 6 7 8 9
依次输出合并了Lb的L的元素：0 1 2 3 5 6 7 8 9 15 14 13 12 11 10
请按任意键继续. . .

3.2.6 完整代码

如下：

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20              /*定义顺序表的最大容量*/
typedef int ElemType;
typedef struct{
    ElemType data[MAXSIZE];     /*存储数据元素*/
    int length;                 /*线性表当前长度*/
}SqlList;

/*Status是函数的类型，其值是函数返回结果的状态码，如OK*/
typedef int Status;

/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值，注意i是指位置，第1个位置的数组是从0开始的*/
Status GetElem(SqlList L,int i,ElemType *e){
    if(L.length==0 || i<1 || i>L.length)
        return ERROR;
    *e=L.data[i-1];

    return OK;
}

/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
Status ListInsert(SqlList *L,int i,ElemType e){
    int k;
    if (L->length==MAXSIZE)                 /*线性表已满*/
        return ERROR;
    if (i<1 || i>L->length+1)                 /*i位置判断，比第一位置小，比最后位置大*/
        return ERROR;
    
    if (i<=L->length){                      /*如果插入位置不在表尾*/
        for(k=L->length-1;k>=i-1;k--)       /*将要插入位置后的元素向后移一位*/
            L->data[k+1]=L->data[k]; 
    }
    L->data[i-1]=e;                         /*将新元素插入*/
    L->length++;                            /*线性表长度加1*/

    return OK;
}


/*初始条件：顺序表L已存在，1<=i<=ListLength*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/
Status ListDelete(SqlList *L,int i,ElemType *e){
    int k;
    if (L->length==MAXSIZE)                 /*线性表已满*/
        return ERROR;
    if (i<1 || i>L->length)                 /*删除位置不正确*/
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length){                        /*如果删除不是最后位置*/
        for(k=i;k<L->length;k++)             /*将删除后继元素前移*/
            L->data[k-1]=L->data[k];       
    }
    L->length--;
    return OK;
}



/*初始化线性表*/
Status InitList(SqlList *L){
    L->length=0;
    return OK;
}

/*判断是否为空表*/
Status isEmpty(SqlList L){
    if (L.length==0){
        return TRUE;
    }else{
        return FALSE;
    } 
}

/*返回线性表元素个数*/
int ListLength(SqlList L){
    return L.length;
}



/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqlList L,ElemType e){
    int i;
    if (L.length==0){
        return 0;
    }
    for (i=0;i<L.length;i++){
        if (L.data[i]==e){
            break;
        }
    }

    if (i>=L.length)
        return 0;
    
    return i+1;   /*返回该值所在位置*/
}

/*遍历线性表*/
Status visit(ElemType c){
    printf("%d ",c);
    return OK;
}

Status ListTraverse(SqlList L){
    int i;
    for(i=0;i<L.length;i++){
        visit(L.data[i]);
    }
    printf("\n");
    return OK;
}

/*将所有的在线性表Lb中但不在La中的数据元素插入到La中*/
void unionL(SqlList *La,SqlList Lb){
    int La_len,Lb_len,i;
	ElemType e;                        /*声明与La和Lb相同的数据元素e*/
	La_len=ListLength(*La);            /*求线性表的长度 */
	Lb_len=ListLength(Lb);

    for(i=1;i<=Lb_len;i++){
        GetElem(Lb,i,&e);               /*将Lb中第i个元素存储到e中*/
        if (!LocateElem(*La,e))         /*如果La中不存在与e相同的数据元素*/
            ListInsert(La,++La_len,e);  
    }
}

/*清空线性表*/
Status ClearList(SqlList *L){
    L->length=0;
    return OK;
}

/*测试代码*/
int main(){
        
    SqlList L;
	SqlList Lb;
    
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);
    i=isEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：L.length=%d\n",L.length);
    i=isEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L); 
    printf("L.length=%d \n",L.length);

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d个元素的值为%d\n",k,j);
            else
                    printf("没有值为%d的元素\n",j);
    }
    

    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 删除第j个数据 */
            if(i==ERROR)
                    printf("删除第%d个数据失败\n",j);
            else
                    printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

	//构造一个有10个数的Lb
	i=InitList(&Lb);
    for(j=6;j<=15;j++)
            i=ListInsert(&Lb,1,j);

	unionL(&L,Lb);

	printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L); 

    system("pause");

    return 0;
}
压力小子呀
关注
专栏目录
线性表的顺序存储结构（C语言版）
weixin_41778615的博客
04-10 1033
线性表的顺序存储结构代码 #define MAXSIZE 20 /*存储空间初始分配量*/ typedef int ElemType; /*ElemType类型根据实际情况而定，这里假设为int*/ typedef struct { ElemType data[MAXSIZE ]; /*数组存储数据元素，最大值为MAXSIZE*/ int length;...
【数据结构】线性表的顺序存储结构
z1zyy的博客
03-29 2552
C++实现线性表的顺序存储结构 ---- 顺序表
顺序存储结构的线性表
徐永赛的博客
07-18 1900
顺序存储结构的线性表
线性表--顺序存储结构
hongcaixia的博客
03-08 6034
一、线性表的顺序存储结构 线性表有两种物理存储结构：顺序存储结构和链式存储结构。 顺序存储结构 ①定义： 用一段地址连续的存储单元依次存储线性表的数据元素。 ②线性表（a1,a2,…,an）的顺序存储如下： 物理上的存储方式事实上就是在内存中找个初始地址，然后通过占位的形式，把一定的内存空间给占了，然后把相同数据类型的数据元素依次放在这块空地中。 ③线性表顺序存储结构...
线性表顺序存储结构
qq_34535590的博客
02-28 843
目录 线性表的定义 线性表的顺序存储结构 顺序存储结构的插入与删除 线性表的定义 线性表(List): 零个或者多个数据元素的有限序列 注意: 序列说明元素之间是有顺序的,若元素存在多个,则第一个元素无前驱,最后一个元素无后继,其他每个元素都有,且只有一个前驱和后继, 是有限的,事实上,计算机处理的对象都是有限的 线性表抽象数据结构定义 前面给出了线性表的定义,现在分析一下线性表...
C语言线性表顺序存储结构实例详解
08-30
C语言线性表顺序存储结构实例详解 本资源主要介绍了C语言线性表顺序存储结构实例的相关知识点，涵盖了顺序存储结构的定义、线性表的顺序存储结构的实现、顺序表的初始化操作、获取元素操作、插入操作和删除元素操作...
c代码-线性表顺序存储结构
07-16
本资料包主要包含了用C语言实现线性表顺序存储结构的相关代码。 `README.txt`可能是对整个项目的一个简短说明，通常包括如何编译和运行程序的指示，以及任何重要的注意事项或功能概述。由于我们无法直接查看这个...
数据结构--线性表(1)--顺序存储篇
smilejianyue的博客
05-29 1210
线性表是最常见且简单的的一种线性结构。 由n个（n为线性表的长度，当n=0时，线性表为空表）数据特性相同的元素构成的有限序列称为线性表。对于非空线性表或者线性结构，其特点有： ** 1）.表中数据元素个数有限，数据类型同类，有先后次序。 2）.表中都是数据元素，每个元素都是单个元素。 3）. 除第一个数据元素外，其余元素都有前驱 4）. 除最后一个数据元素外，其余元素都有后继 （前驱和后继：比如排队，在你前面的就可以称为前驱，在你后面的，称为后继）**InitList(&L)：初始化线性表，构造一个空线性表
【数据结构】线性表的顺序存储
最新发布
DAY I 的成长之路
04-24 4146
💯线性表是具有相同类型的数据类型的n个数据元素的有限序列，其中n为表长，n0n=0n0时为空表ege.geg这里要注意的是，定义中描述的为数据元素，而非数据项，也就是，存储单元可以是一个结构体，而数据项为里面的成员✨线性表的特点：表中元素的个数为有限个表中元素具有逻辑上的顺序性，表中元素有其先后顺序表中元素都是数据元素，每一个元素都为单个元素表中元素的数据类型都相同，每个元素占相同的内存空间表中元素具有抽象性，即仅讨论元素之间的逻辑关系，而不考虑具体实现方式🔑。
线性表-定义和顺序存储结构
朝花夕拾
02-26 2820
3.1 开场白 各位同学，大家好。 今天我们要开始学习数据结构中最常用和最简单的一种结构，在介绍它之前先讲个例子。 我经常下午去幼儿园接送儿子，每次都能在门口看到老师带着小朋友们， 一个拉着另一个的衣服，依次从教室出来 。而且我发现很有规律的是，每次他们的次序都是一样。比如我儿子排在第 5 个，每次他都是在第 5 个，前面同样是那个小女孩，后面一直是那个小男孩。这点让我很奇怪，为
数据结构与算法——线性表的顺序储存结构
xzt12138的博客
07-20 6998
顺序储存结构就是在内存中找了一块地，将一组数据以连续的方式将其储存在这块内存中。而且每个元素的数据类型相同，所以我们可以用C语言的一维数组来实现顺序储存结构。即，把第一个数据元素存到下标为0的位置，接着把线性表相邻的元素储存在数组中相邻的位置。......
数据结构与算法学习总结-线性表的顺序存储与实现
空谷回响的编码史
01-12 2711
线性表的顺序存储是用一组地址连续的存储单元一次存储线性表的数据元素。 1.线性表的顺序存储 　　假设线性表的每个数据元素需占用K个存储单元，并以元素所占的第一个存储单元的地址作为数据元素的存储地址。则线性表中序号为i的数据元素的存储地址LOC(ai)与序号为i+1的数据元素的存储地址LOC(ai+1)之间的关系为： 　　LOC(ai+1)=LOC(ai)+K 　　通常来说，线性表的i号
数据结构——线性表的链式存储
weixin_69224277的博客
10-01 1484
一看就会的单链表知识
数据结构—线性表的顺序存储结构实现与分析
留恋单行路_Blog
07-07 4587
文章向导 线性表及顺序存储结构 元素获取、插入、删除的实现 算法时间复杂度的分析 一、线性表及顺序存储结构 　　线性表即有限个数据元素的序列，而其顺序存储结构则指的是用一段地址连续的存储单元依次存储线性表中的数据。在高级语言中（如Ｃ语言）一般可用一维数组来实现顺序存储结构。 二、元素获取、插入、删除的实现 　　定义在一个线性表上的操作有许多，比如初始化、清空、读／写、...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

压力小子呀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值