数据结构线性表超详细整理（存取、插入、删除/顺序存储结构/链式存储结构/静态链表/循环链表/双向链表）

最新推荐文章于 2024-04-14 17:07:45 发布
最新推荐文章于 2024-04-14 17:07:45 发布
阅读量3.2k 收藏 21
点赞数 5
分类专栏： 数据结构与算法C语言 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45709829/article/details/120972396
版权
3.1 线性表的定义

定义：零个或者多个数据元素的有限序列

  • 第一个元素无前驱，最后一个元素无后继

  • 线性表元素的个数n(n>=0)定义为线性表的长度，n=0时为空表

  • 排列的必须是相同的数据类型

  • 在较复杂的线性表中，一个数据元素可以由若干个数据项组成

  • 元素之间的是一对一的关系

3.2 线性表的抽象数据类型
ADT 线性表(List)
Data 每个元素的类型均为DataType
Operation
    InitList(*L):初始化操作，建立一个空的线性表
	ListEmpty(L):若线性表为空，返回true，否则返回false
    CleanList(*L):清空线性表
    GetElem(L,i,*e):线性表中的第i个位置元素值返回给e
    LocateElem(L,e):在线性表中查找与给定值e相等的元素，如果查找成功，返回该元素在表中的序号表示成功。否则返回0，失败
    ListInsert(*L,i,e):在线性表L中的第i个位置插入新元素e
    ListDelete(*L,i,*e):删除线性表L中第i个位置元素，并用e返回其值
    ListLength(L):返回线性表L的元素个数
end ADT
3.3 线性表的顺序存储结构

定义：用一段地址连续的存储单元依次存储线性表的数据元素

数据元素强调相同数据类型

3.3.2 顺序存储方式

可以用一维数组来实现

why?cuz线性表每个数据元素的类型都相同

//顺序存储的结构代码
#define MAXSIZE 20 //存储空间的初始分配量
typedef int ElemType; //类型根据具体情况而定
typedef struct{
    ElemType data[MAXSIZE]; //数组存储元素，最大值为MAXSIZE
    int length; //线性表当前的长度
}SqList;

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

  1. 数组的长度是存放线性表的存储空间长度
  2. 线性表的长度是线性表中数据元素的个数，根据插入，删除动态分配
  3. 任何时刻，线性表的长度<=数组的长度

存取时间性能为O(1)，通常把具有此类特定的存储结构成为随机存取结构

3.3.3 顺序存储结构的插入和删除

  • 获得元素操作
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;/*Status是函数类型，其值是函数结果的状态代码，如OK*/
				 /*Status是一个整型，返回1或者0*/
				 /*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
				 /*操作结果；用e返回L中第i数据元素的值*/
Status GetElem(Sqlist L,int i,ElemType *e)
{
    if(L.length == 0|| i < 1 || i>L.length)
        return ERROR;
    *e = L.data[i-1];
    	return OK;
}

  • 插入元素操作

    算法思路：

    ​ * 如果插入的位置不合理，抛出异常

    ​ * 如果线性表的长度大于数组的长度，抛出异常或者动态增加容量

    ​ * 从最后一个元素向前遍历到第i个位置，分别将它们后移一个位置

    ​ * 把元素插入第i个位置

    ​ * 表长+1

/*初始条件：顺序线性表L已存在，1<=i<ListLength(L)*/
/*操作结果：在L中第i个位置之前插入新的元素，表长+1*/
Status ListInsert(Sqlist *L,int i,ElemType e)
{
    int k;
    if(L->length==MAXSIZE)
        return ERROR; /*顺序线性表已经满*/
    if(i < 1 || i > L->length+1)
        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++;
    return OK;
}

  • 删除元素操作

    算法思路

    ​ *如果删除位置不正确，抛出异常

    ​ *取出删除元素

    ​ *如果删除的不是最后一个位置从删除元素位置起向后遍历到最后一个元素位置，将它们往前移动一个位置

    ​ *表长-1

/*初始条件：顺序线性表L已存在，1<=i<ListLength(L)*/
/*操作结果：删除L中的第i个数据元素，并用e返回其值，L的长度-1*/
Status ListDelete(Sqlist *L,int i,ElemType *e)
{
    int k;
    if(L->length==0)
        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;
}

一个小插曲

在学习线性表的时候，我在书上写下，为什么插入要（E）

时间复杂度分析

存，读数据为O(1),插入删除为O(n)

线性表顺序存储的优缺点

优点：

  1. 无须为表示表中元素之间的逻辑关系而增加额外的存储空间
  2. 可以快去存取表中任一位置的元素

缺点：

  1. 插入和删除操作需要移动大量的元素
  2. 当线性表长度变化较大的时候，难以确定存储空间
  3. 造成存储空间的碎片，造成存储空间浪费
3.4 线性表的链式存储结构

n个node链结成一个链表，即为线性表(a1，a2,…,an)的链式存储结构，因为此链表的每个node只包含一个指针域，所以叫单链表。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7i0rC7Vp-1635231668869)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316171059107.png)]

头指针：链表中第一个node的存储位置叫头指针

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JWKrtTLp-1635231668873)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316193855223.png)]

为了对链表进行更方便的操作，会在单链表的第一个node前附设一个头node

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M3EzzKtv-1635231668876)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316194335689.png)]

头指针与头结点node的异同

头指针：* 指链表指向第一个node的指针，若链表有头node，则是指头node的指针

​ * 头指针具有标识作用，所以常用头指针冠以链表的名字

​ * 无论链表是否为空，头指针都不为空

头结点：* 为了操作的统一和方便而设立的，放在第一元素的node之前，其数据域一般无意义，也可存放链表的长度

​ * 对第一元素结点node前插入node和删除node操作统一

​ * 头结点node不一定是链表的必须要素

我们主要关心的是数据元素和数据元素之间的逻辑关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-19M3isPb-1635231668880)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316195835877.png)]

单链表，结构指针代码如下

/*线性表的单链表存储结构*/
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList;/*定义LinkList*/

node由存放数据元素的数据域和存放后继node的指针域组成。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-11ExHLEu-1635231668881)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316200939686.png)]

3.4.1 单链表的基本操作

  • 单链表的读取

算法思路

  1. 声明一个指针p指向链表的第一个node，初始化j从1开始
  2. 当j<i时，遍历链表，让p的指针向后移动，不断指向下一个node，j+1
  3. 若到链表末尾p为空，则说明第i个node不存在
  4. 否则查找成功，返回node p的数据

算法的时间复杂度取决于i的位置。

/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;
    p = L->next;/*声明一个指针p*/
    j=1; /*j为一个计数器*/
    while (p && j<i)
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
        return ERROR;
    *e = p->data;
    return OK;
}

为什么用while循环不用for循环？

cuz单链表结构中没有定义表长，不知道循环多少次，不方便用for来控制

  • 单链表的插入和删除

插入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wuMyVutV-1635231668883)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316203331175.png)]

s->next = p->next;
p->next = s;

p的后继node改为s的后继node，再把p->next改成s

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ARaLqNDu-1635231668885)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316203402489.png)]

插入算法思路

  1. 声明一指针p指向链表头结点，初始化j从1开始
  2. 当j<i时，遍历链表，让p指针往后移，不断指向下一个node，j+1
  3. 若链表的末尾p为空，则说明第i个结点不存在
  4. 否则查找成功，在系统生成一个空node结点s
  5. 将数据e赋值给s->data
  6. 单链表插入标准语句 s->next = p->next; p->next = s;
  7. 返回成功
/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：在L中第i个结点位置之前插入新的数据元素e，L的长度+1*/
Status ListInsert(LinkLikst *L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    while(p && j < i);/*寻找第i-1个node*/
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
        return ERROR;
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}
  • 删除

把p的后继node，改成p的后继的后继的node

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G44LRtnD-1635231668886)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210316205513844.png)]

q = p->next;
p->next = q->next;

删除算法思路

  1. 声明一指针p指向链表头指针，初始化j从1开始
  2. 当j<i时，遍历链表，让p指针往后移，不断指向下一个node，j+1
  3. 若链表的末尾p为空，则说明第i个结点不存在
  4. 否则查找成功，将欲删除的结点 p->next赋值给q
  5. 单链表的删除标准语句 p->next = q->next
  6. 将q结点的数据赋值给e，作为返回
  7. 释放结点q；
  8. 返回成功
/*初始条件：顺序线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果:删除L的第i个结点，并用e返回其值，L的长度域-1*/
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j;
    LinkList q,p;
    p = *L;
    j = 1;
    while(p->next && j<i)
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || j>i)
        return ERROR;
    q = p->next;
    *e = q->data;
    free(q);/*C语言的标准函数free，它的作用就是让系统回收一个Node，释放内存*/
    return OK;
}

对于插入和删除数据越频繁的操作，单链表的效率优势是明显。

  • 单链表的创建==动态生成链表的过程，空表开始建立

算法思路

  1. 声明一指针p和计数器变量i

  2. 初始化一空链表L

  3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表

  4. 循环 * 生成一新结点赋值给p

    ​ * 随机生成一个数字赋值给p的数据域p->data

    ​ * 将p插入到头结点与前一新结点之间

​ 头插法

/*随机产生n个元素的值，建立带头结点的单链线性表L（头插法）*/
void CreateListHead(LinkList *L,int n)
{
    LinkList p;
    srand(time(0));/*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;/*先建立一个带头结点的单链表*/
    for(i = 0;i < n;i++ )
    {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;/*随机生成100以内的数字*/
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

​ 尾插法

/*随机产生n个元素的值，建立带头结点的单链线性表L（尾插法）*/
void CreateListTail(LinkList *L,int n)
{
    LinkList p,r;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for(i = 0;i < n;i++)
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;
    }
    r->next = NULL;
}

单链表的整表删除

算法思路

  1. 声明一个结点p和q
  2. 将第一个结点赋值给p
  3. 循环
  • ​ 将下一个结点赋值给q
  • ​ 释放p
  • ​ 将q赋值给p
/*初始条件：顺序线性表已存在*/
/*将L重置为空表*/
Status CleanList(LinkList *L)
{
    LinkList p,q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
    return OK;
}

为什么要设置变量q？

cuz：在释放free§的时候，p包括指针域和数据域，释放的时候把指针域也释放了，下一个结点无法找到，所以需要q。

单链表结构与顺序存储结构的优缺点

1存储分配方式

  • 顺序存储结构用一段连续的存储单元依次存储数据元素。
  • 单链表采用链式存储结构，用任意一组存储单元存放线性表的数据元素，开辟空间不连续

2时间性能

  • 查找:顺序存储结构0(1),单链表0(n)
  • 插入和删除：顺序存储结构O(n),单链表O(1)

3空间性能

  • 顺序存储结构需要预先分配存储空间，容易造成空间浪费，也容易发生上溢
  • 单链表动态分配存储空间。
3.5静态链表

定义：用数组描述的链表叫做静态链表(游标实现法，data，cur)

/*线性表的静态链式存储结构*/
#define MAXSIZE 1000
typedef struct
{
    ElemType data;
    int cur;/*游标curson，为0时无指向*/
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-laoqZXfE-1635231668888)(C:\Users\Gabrielle\AppData\Roaming\Typora\typora-user-images\image-20210317154701193.png)]

以上图示相当于初始化的数组状态

/*将一维数组space中分量链成一备用表*/
/*sapce[0].cur为头指针，"0"表示空指针*/
Status InitLink(StaticLinkList space)
{
    int i;
    for(i = 0;i < MAXSIZE-1;i++)
 		space[i].cur = i + 1;
	space[MAXSIZE-1].cur  = 0;/*目前链表为0，最后一个数据元素的cur为0*/
    return  OK;
}

在动态链表中，结点的申请和释放分别借用malloc()和free()两个函数来实现。静态链表操作的是数组，静态链表的插入和删除，需要编写实现函数。

静态链表其实是为了给没有指针的高级语言设计的一种实现

插入

/*若备用空间链表非空，则返回分配的结点下标，否则返回0*/
int  Malloc_SLL(StaticLinkList space)
{
    int i = space[0].cur;
    if(space[0].cur)
        space[0].cur = space[i].cur;
    return i;
}

/*在L中第i个元素之前插入新的数据元素e*/
Status ListInsert(StaticLinkList L,int i,ElemType e)
{
    int j,k,l;
    k = MAX_SIZE-1;	/*k是最后一个元素的下标*/
    if(i <1 ||i > ListLength(L) + 1)
	return ERROR;
    j = Malloc_SSL(L);	/*获取空闲分量的下标*/
    if(j)
    {
        L[j].data = e;
        for(l = 1; l <=i-1; l++) /*找到第i个元素之前的位置*/
            	k = L[k].cur;
        
        L[j].cur = L[k].cur; /*把第i个元素之前的cur赋值给新的元素*/
        L[k].cur = j; /*把新元素的下标赋值给第i个元素之前元素的cur*/
        
        return OK;
    }
    return ERROR;
}

删除

/*删除在L中第i个数据元素，相当于free()*/
Status ListDelete(StaticLinkList L,int i)
{
    int j,k;
    if(i < 1 || i > ListLength(L))
	return ERROR;
    k = MAX_SIZE-1;
    for(j = 1;j<= i-1;j++)
 		k = L[k].cur;
    j = L[k].cur;
    L[k].cur = L[j].cur;
    Fred_SSL(L,j);
    return OK;
}

void Free_SSL(StaticLinkList space,int k)
{
    space[k].cur = space[0].cur;
    space[0].cur = k;
}

静态链表的优缺点

优点

在插入和删除操作的时候不需要移动元素，改进顺序存储结构中进行插入和删除操作的时候需要移动大量元素的缺点

缺点

表长难以确定，无法解决分配空间带来的问题，可能造成空间浪费

没有顺序存储结构随机存取的特性

3.6 循环链表

3.6.1 定义—什么是循环链表

将单链表中终端结点的指针端由空指针改成指向头结点，使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表（circular linked list）

单链表和循环链表的区别

最突出的是在循环的判断条件上。单链表判断p->next是否为空，循环链表判断p->next是否等于头结点。

3.6.2 循环链表

  • 空循环链表

通常设置一个头结点（但是不是每一个空的循环链表都需要一个头结点），如图
在这里插入图片描述

  • 非空循环链表

在这里插入图片描述

3.7 双向链表

定义—什么是双向链表

双向链表（double linked list）是在单链表的每一个结点中，再设置一个指向其前驱结点的指针域。在双向链表中，有两个指针域，一个指向直接后继，一个指向直接前驱。

/*线性表的双向链表存储结构*/
typedef struct DulNode
{
    ElemType data;
    struct DulNode *prior;/*直接前驱指针*/
    struct DulNode *next;/*直接后继指针*/
}DulNode,*DulinkList;

插入

在这里插入图片描述

在操作插入的时候代码的顺序很重要

（1）插入S结点的前驱（prior）

（2）插入S结点的后继（next）

（3）后结点的前驱（prior）

（3）后结点的后继（next）

s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;

删除

在这里插入图片描述

删除只需要两步，相比较插入简单一点

（1）前结点的后继（next）

（2）后结点的前驱（prior）

p->prior->next = p->next;
p->next->prior = p->prior;

总结
在这里插入图片描述

傲娇味的草莓
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构—线性表的定义与基本操作【插入、删除、查找】
四季轮换叶，一路招摇胜
03-28 8328
线性表：是一种最常用、最简单，也是最基本的数据结构。 线性表是由n(n>= 0)个数据元素所构成的有限序列，且数据类型相同。 线性表中数据元素之间具有一种线性的或“一对一”的逻辑关系。线性表是一种线性结构。 线性表可以用顺序存储和链式存储两种存储结构来表示。...
线性表的三种基本操作（插入、删除、操作）！！！
Mrllir的博客
09-12 8861
C语言定义： #define maxsize 线性表肯定达到的最大长 typedef struct //结构体 { ElemType elem[maxsize]; int length; }SeqList; SeqList L;或 SeqList *L; 注意：区分元素的序号和数组的下标，如a1的序号为1，而其对应的数组元素L.elem[0]。或者不使用下标为0的单元，序号和下标保持一致，多占用一个元素空间即可。 基本运算： ①查找操作 按序号查找GetData(L,i);要求查找..
线性表学习02——线性表的顺序表示和实现
最新发布
2301_80034711的博客
04-14 1058
P(n)(x)=p1x的e1次方+p2x的e2次方+...+p(m)x的e(m)次方：线性表P=((p1,e1),(p2,e2),...,(pm,em))//多项式可能达到的最大长度//多项式非零项的定义float p；//系数int e；//指数//存储空间的基地址int length；//多项式中当前项的个数｝SqList；//多项式的顺序存储结构类型为SqList实例② 图书表的顺序存储结构类型定义//图书表可能达到的最大长度//图书信息定义//图书ISBN。
数据结构基础——线性表之顺序表的插入删除查找操作（附C语言代码）
qq_62316014的博客
04-14 1829
本文阐述了顺序表的一些基本操作——插入删除查找，并附上C语言代码。
数据结构 线性表 插入 删除
热门推荐
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
【数据结构与算法】(8)：顺序队列、链式队列和循环队列
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
06-02 708
链式队列的实现，顺序队列的实现，循环队列的实现
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **概念与结构**：链表是一种非连续、非顺序的存储结构，数据元素之间的逻辑顺序通过指针链接实现。链表可以是单向或双向，带头或不带头，循环或非循环。 - **链表分类**：在实际应用中，最常见的链表类型是无头...
python数据结构之线性表的顺序存储结构
12-24
用Python仿照C语言来实现线性表的顺序存储结构，供大家参考，具体内容如下 本文所采用的数据结构模板为 《数据结构教程》C语言版，李春葆、尹为民等著。 该篇所涉及到的是线性表的顺序存储结构。 代码： # !/usr/...
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
实验内容： （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度...编写一个算法将此表改为循环双链表。
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数组和链表.pdf
04-18
物理结构也可以分为几种，如顺序存储结构、链式存储结构、索引存储结构、散列存储结构等。其中顺序存储结构是一种常见的物理结构，它使用一组连续的存储单元依次存储数据元素。 顺序表、链表和数组是 üç种不同的...
数据结构与算法-链表（线性表的链表表示和实现） 定义线性表节点的结构.pdf
04-18
链表是一种线性表的链式表示和实现，定义线性表节点的结构。链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。一个链表有很多个节点，各个节点之间通过指针连接起来，...
数据结构课件 队列是只允许在一端删除，在另一端插入的线性表。
01-07
数据结构课件 队列是只允许在一端删除，在另一端插入的线性表。
线性表的链式存储——表长、查找、插入、删除
qq_54731568的博客
02-22 410
线性表的链式存储——表长、查找、插入、删除
数据结构实验二 线性表顺序结构的删除、插入操作
qq_64314976的博客
08-06 2803
删除操作的实现，任意输入一个要删除的整数，找到这个元素，将此元素之后的所有元素逐个前移一位，实现删除操作。使用C语言中的数组，实现线性表中的顺序结构存储的查找、删除、插入操作。、初始线性表通过数组、循环、scanf语句实现输入任意个整数。请任意输入整型一维数组：1，3，5，7，9，2，4，6，8，0。、当线性表中的数据数量已被删除至零时提示“线性表已空”。删除之后为：1，3，5，7，9，2，6，8，0。删除之后为：1，5，7，9，2，6，8，0。请输入要删除的值： 4。请输入要删除的值：3。......
c++ 线性表之顺序储存结构 左插入 右插入 删除元素
weixin_39926429的博客
01-03 422
//在c++ builder 平台调试通过 #include <iostream> #include <string> using namespace std; #define Size 5 typedef struct Table { int *head; int length; int size; }table; table initTable() { table t; t.head=(int*)malloc (Size*sizeof(...
线性表（顺序表）的初始化，取值，查找，插入及删除（c++）
m0_74472474的博客
09-11 6693
顺序表中的基本操作以及描述（基本操作包括对线性表进行初始化，取值，查找元素，插入元素以及删除元素)
数据结构链表的初始化插入删除_算法设计：数据结构-线性表
weixin_39760065的博客
11-22 231
(一)线性表的概念线性表是具有相同特性元素的有限序列。该序列中所含元素的个数叫做线性表的长度，用n表示(n>=0)，注意，n可以等于0表示是一个空表注意：不同的线性表的数据元素可以不同，但对于同一线性表，各数据元素必须具有相同的数据类型，即同一线性表中各数据元素具有相同的类型，每个数据元素的长度形同线性表数据结构具有以下特征：1、有且只有一个首元素2、有且只有一个尾元素3、除尾元素之外，其余...
数据结构之线性表插入与删除运算
AIMing_byte的博客
02-19 1472
线性表，或称表，是一种非常灵便的结构，可以根据需要改变表的长度，也可以在表中任何位置对元素进行访问、插入或删除等操作。另外，还可以将多个表连接成一个表，或把一个表拆分成多个表。例如，26个英文字母的字母表：（A，B，C，......，Z）就是一个线性表，表中的数据元素是单个字母。在稍复杂的线性表中，一个数据元素可以包含若干个数据项。例如在学生基本信息表中，每个学生为一个数据元素，包括学号、姓名、性别、籍贯、专业等数据项。
3、线性表的顺序存储结构（顺序表）
Lesour的博客
03-29 3368
线性表的顺序存储结构是把线性表中的元素中的元素按照其逻辑顺序依次存储到计算机存储器中指定位置开始的一块连续的存储空间中，它直接将线性表的逻辑结构映射到存储结构上，既方便理解，又容易实现。 ...
线性表的顺序存储结构优于链表存储结构
07-08
线性表的顺序存储结构和链表存储结构都有各自的优缺点，不能一概而论。 顺序存储结构的优点： 1. 存储密度高，每个元素都占用同样大小的存储空间，便于计算存储位置，随机访问元素非常快速。 2. 线性表长度固定，空间利用率高。 3. 元素之间的逻辑关系通过元素在空间中的相对位置来表示，容易理解。 顺序存储结构的缺点： 1. 线性表长度固定，插入和删除元素时需要移动大量元素，效率低下。 2. 插入和删除操作可能导致存储空间的浪费或不足，需要进行空间的重新分配，增加了编程难度。 3. 顺序存储结构只适合存储元素数量固定，查找和访问次数多的场景。 链表存储结构的优点： 1. 插入和删除元素时只需要修改指针，不需要移动元素，效率高。 2. 链表长度不固定，空间利用率高，可以动态分配内存空间。 3. 链表存储结构适合存储元素数量不固定，插入和删除操作频繁的场景。 链表存储结构的缺点： 1. 存储密度低，每个元素都需要额外的指针存储空间，增加了存储开销。 2. 访问元素需要遍历整个链表，效率相对较低。 3. 元素之间的逻辑关系通过指针来表示，理解起来相对困难。 因此，选择线性表的存储结构需要根据实际应用需求进行权衡和选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

傲娇味的草莓

佛系少女只是想记录学习痕迹

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

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

打赏作者

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

抵扣说明：

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

余额充值