数据结构-线性表(7.12)

最新推荐文章于 2022-01-13 10:40:03 发布
最新推荐文章于 2022-01-13 10:40:03 发布
阅读量220 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangsena/article/details/118667388
版权

文章目录

写在开头

用于自己考研复习巩固

一、线性表基本操作

  • InitList(&L)-初始化表
  • Length(L)-求表长
  • LocateElem(L,e)-按值查找
  • GetElem(L,i)-按位查找
  • ListInsert(&L,i,e)-插入
  • ListDelete(&L,i,&e)-删除
  • printfList(L)-输出
  • Empty(L)-判空
  • DestroyList(&L)-销毁

&表C/C++中的引用调用，即对参数的修改结果要带回来

二、顺序表

2.1顺序表的实现

2.1.1静态数组

#define Maxsize 50           //定义最大长度
typedef struct
{
    ElemType data[Maxsize];  //静态数组存放数据元素
    int length;              //顺序表当前长度
} SqList;

//初始化顺序表
void InitList(SqList &L)
{
    for(int i=0; i<Maxsize; i++)
        L.data[i]=0;         //设置默认元素初始值，不然内存会有脏数据
    L.length=0;          //设置初始长度为0
}

缺点：数组的大小和空间事先固定。一旦空间满，加入新的数据就会产生溢出，导致程序崩溃。

2.1.2动态分配

//动态分配
#define InitSize 50     //长度的初始定义
typedef struct
{
    ElemType *data;     //动态分配数值的指针
    int Maxsize;        //顺序表最大容量
    int length;         //顺序表当前长度
} SqList;

//初始化顺序表
void InitList(SqList &L)
{
    //用malloc函数申请一片连续的储存空间
    L.data=(ElemType *)malloc(InitSize*sizeof(ElemType ));
    L.length=0;
    L.MaxSize=InitSize;

//空间不够，动态增加数组长度
void Increase(SqList &L,int len)
{
    int *p=L.data;
    L.data=(ElemType *)malloc((L.MaxSize+len)*sizeof(ElemType ));
    for(int i=0; i<L.length; i++)
        L.data[i]=p[i];             //将数据复制到新区域
    L.MaxSize+=len;                 //顺序表最大长度增加len
    free(p);                        //释放原空间
}

2.1.3小结

_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nc2VuYQ==,size_16,color_FFFFFF,t_70)

2.2顺序表的插入与删除

2.2.1顺序表的插入

//顺序表的插入（以静态数组为例）（1<=i<=length+1）
    bool LinkList(SqList &L,int i,ElemType e)
    {
        if(i<1||i>L.length+1)
            return false;
        if(i>=Maxsize)
            return false;
        for(int j=L.length; j>=i; j--)
            L.data[j]=L.data[j-1];
        L.data[i-1]=e;
        L.length++;
        return true;
    }

注意数组下标和位序

2.2.2顺序表的删除

//顺序表的删除
    bool ListDelete(SqList &L,int i,ElemType &e)
    {
        if(i<1||i>L.length)
            return false;
        e=L.data[i-1];
        for(int j=i; j<L.length; j--)
            L.data[j-1]=L.data[j];
        L.length--;
        return true;
    }

注意&e，把删除的值e带回来

2.2.3小结

在这里插入图片描述

2.3顺序表的查找

2.3.1按位查找

//按位查找
    ElemType GetElem(SqList L,int i)
    {
        return L.data[i-1];
    }

2.3.2按值查找

//按值查找
    int LocateElem(SqList L,ElemType e)
    {
        for(int i=0; i<L.length; i++)
        {
            if(L.data[i]==e)
                return i+1;
        }
        return 0;
    }

1.在C语言中结构的比较不可以直接用==
2.但在《数据结构》考研初试中，手写代码可以用==，无论是基本数据类型还是结构类型

2.3.3小结

在这里插入图片描述

2.4易错试题

1.线性表的顺序存储结构是一种（）
A.随机存取的顺序结构
B.顺序存取的顺序结构
C.索引存取的顺序结构
D.散列存取的顺序结构

A。存取方式指的是读写方式，顺序表是一种支持随机存取（在计算机科学中，随机存取（有时亦称直接访问）代表同一时间访问一组序列中的一个随意组件。）的存储结构。

三、链表

3.1单链表

3.1.1单链表的定义

3.1.1.1定义及初始化
//链表的定义
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode,*LinkList;

//初始化空的单链表
bool InitList(LinkList &L)
{
    L=NULL;         //防止脏数据
    return true;
}
/ / 判断表空
bool Empty(LinkList L)
{
    return (L==NULL);
}

//初始化带头结点的单链表
bool InitList(LinkList &L)
{
    L=(LNode *)malloc(sizeof(LNode));
    if(L==NULL)
        return false; //内存不足分配失败
    L->next=NULL;
    return true;
}
//判断表空
bool Empty(LinkList L)
{
    if(L->next==NULL)
        return false;
    return true;
}

LinkList 强调这是一个单链表
LNode * 强调这是一个结点

3.1.1.2小结

在这里插入图片描述

3.1.2单链表的插入

3.1.2.1按位序插入
//按位序插入（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e)
{
    if(i<1)
        return false;
    LNode *p;       //p指针指向当前扫描到的结点
    int j=0;        //p当前指向的是第几个结点
    p=L;            //L指向第0个结点，是头结点
    while(p!=NULL&&j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
    }
    if(p==NULL)     //i的值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

//按位序插入（不带头结点）
bool ListInsert(LinkList &L,int i,ElemType e)
{
    if(i<1)
        return false;
    if(i==1)        //插入第一个结点操作略有不同
    {
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;
        return true;
    }
    LNode *p;       //p指针指向当前扫描到的结点
    int j=1;        //p当前指向的是第几个结点
    p=L;            //L指向第1个结点，不是头结点！！
    //与带头结点一样
    while(p!=NULL&&j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
    }
    if(p==NULL)     //i的值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

带头结点的插入要注意，插入第一个要单独区别

3.1.2.2指定结点的后插
//指定结点的后插
bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)         //内存分配失败
        return false;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

对3.1.2.1按位序插入中带头和不带头的相同代码部分进行封装如下：

//按位序插入（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e)
{
    if(i<1)
        return false;
    LNode *p;       //p指针指向当前扫描到的结点
    int j=0;        //p当前指向的是第几个结点
    p=L;            //L指向第0个结点，是头结点
    while(p!=NULL&&j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
    }
    return InsertNextNode(p,e);
}

//按位序插入（不带头结点）
bool ListInsert(LinkList &L,int i,ElemType e)
{
    if(i<1)
        return false;
    if(i==1)        //插入第一个结点操作略有不同
    {
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;
        return true;
    }
    LNode *p;       //p指针指向当前扫描到的结点
    int j=1;        //p当前指向的是第几个结点
    p=L;            //L指向第1个结点，不是头结点！！
    //与带头结点一样
    while(p!=NULL&&j<i-1) //循环找到第i-1个结点
    {
        p=p->next;
        j++;
    }
    return InsertNextNode(p,e);
}
3.1.2.3指定结点的前插
//指定结点的前插
bool InsertPriorNode(LNode *p,ElemType)
{
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->next=p->next;
    p->next=s;
    s->data=p->data;
    p->data=e;
    return true;
}

3.1.3单链表的删除

3.1.3.1按位序删除
//按位序删除(带头结点)
bool ListDelete(LinkList &L,int i,ElemType &e)
{
    if(i<1)
        return false;
    LNode *p;
    int j=0；
          p=L;
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    if(p->next==NULL)
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

//按位序删除(不带头结点)
bool ListDelete(LinkList &L,int i,ElemType &e)
{
    if(i<1)
        return false;
    if(i==1)
    {
        LNode *q=L;
        L=q->next;
    }
    LNode *p;
    int j=1；
          p=L;
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    if(p->next==NULL)
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}
3.1.3.2指定结点的删除
//指定结点的删除
bool DeleteNode(LNode *p)
{
    if(p==NULL)
        return false;
    LNode *q=p->next;
    p-data=p->next->data;
    p->next=q->next;
    free(q);
    return true;
}

如果p是最后一个结点，只能从表头依次往后查找前驱节点，体现了单链表的局限性，无法逆向检索

3.1.3.3小结

在这里插入图片描述

3.1.4单链表的查找

其实在上面的插入和删除中已经涵盖了相关代码

3.1.4.1按位查找
//按位查找(带头结点)
LNode * GetElem(LinkList L,int i)
{
    if(i<0)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while(p!=NULL&&j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}

可以用该函数把删除和插入中对i-1结点的查找替换为LNode * GetEle(L,i-1);

3.1.4.2按值查找
//按值查找(带头)
LNode * locateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}

3.1.5求表长

//求表长(带头结点)
int length(LinkList L)
{
    int len=0;
    LNode *p=L;
    while(p->next!=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}

3.1.4-3.1.5小结

在这里插入图片描述

3.1.6单链表的建立

3.1.6.1尾插法
//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s,*r=L;      //r为表尾指针
    scanf("%d",&x);
    while(x!=9999)      //设置一个结束值
    {
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
    return L;
}
3.1.6.2头插法

理解为对头结点进行后插法

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)
{
    int x;
    LNode *s;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;       //初始为空链表
    scanf("%d",&x);
    while(x!=9999)      //设置一个结束值
    {
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
    return L;
}

重点应用：链表的逆置

3.2双链表

两个指针prior和next

3.2.1定义及初始化

3.2.1.1定义
//定义双链表
typedef struct Dnode
{
    ElemType data;
    struct Dnode *prior,*next;
} DNode,*DLinkList;
3.2.1.2初始化
//初始化双链表
bool InitDLinkList(DLinkList &L)
{
    L=(DNode *)malloc(sizeof(DNode));
    if(L==NULL)
        return false;
    L->prior=NULL;  //头结点的prior永远指向NULL
    L->next=NULL;
    return true;
}

3.2.2插入

//p结点后插入s结点
bool InsertNextDNode(DNode *p,DNode *s)
{
    if(p==NULL||s==NULL)
        return false;
    s->next=p->next;
    if(p->next!=NULL)
        p->next->prior=s;
    s->prior=p;
    p->next=s;
    return true;
}

3.2.3删除

//删除p的后继结点
bool DeleteNextDNode(DNode *p)
{
    if(p==NULL)
        return false;
    DNode *q=p->next;
    if(q==NULL)
        return false;
    p->next=q->next;
    if(q->next!=NULL)
        q->next->prior=p;
    free(q);
    return true;
}

3.2.4小结

在这里插入图片描述

3.3循环链表

3.3.1初始化循环单链表

//循环单链表的初始化
bool InitList(LinkList &L)
{
    L=(LNode *)malloc(sizeof(LNode));
    if(L==NULL)
        return false;
    L->next=L;      //头结点的next指针指向头结点
    return true;
}
//判断空表
bool Empty(LinkList L)
{
    if(L->next==L)
        return true;
    return false;
}

3.3.2初始化循环双链表

//循环双链表的初始化
bool InitDLinkList(DLinkList &L)
{
    L=(DNode *)malloc(sizeof(DNode));
    if(L==NULL)
        return false;
    L->prior=L;
    L->next=L;
    return true;
}
//判断空表
bool Empty(DLinkList L)
{
    if(L->next=L)
        return true;
    return false;
}

3.3.3小结

在这里插入图片描述

3.4静态链表

3.4.1定义

//静态链表的定义
#define MaxSize 10
typedef struct
{
    ElemType data;
    int next;
} SLinkList[MaxSize];

四、顺序表和链表比较

在这里插入图片描述

五、写在最后

付出，才有收获！

森格的博
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线性表（3）--习题
ramay7
08-27 5031
1.带头结点的单链表head为空的判断条件是（B） A.head==NULL B.head->next==NULL C.head->next==head D.head!=NULL 2.不带头结点的单链表head为空的条件是（A） A.head==NULL B.head->next==NULL C.head->next==head D.head!=NULL 3.在一个单链
线性表7 - 数据结构和算法12
weixin_34419326的博客
11-05 71
线性表7 让编程改变世界 Change the world by program 单链表的整表创建 对于顺序存储结构的线性表的整表创建，我们可以用数组的初始化来直观理解。 而单链表和顺序存储结构就不一样了，它不像顺序存储结构数据这么集中，它的数据可以是分散在内存各个角落的，他的增长也是动态的。 对于每个链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根...
数据结构与算法 --- 第二章(1) 线性表(顺序存储)
JORDANHCH的博客
01-13 577
数据结构与算法 第二章 线性表 1. 线性表的定义   大家好，首先还是要先感谢大家来看我的文章。今天，我们要学习的是数据结构中最常用且很简单的一种结构，也就是线性表，它是一个能存储零个或多个数据元素的有限序列。就像我们生活中排队一样，有头有尾，并且除了首尾两个人外，其他的人都知道自己前面是谁，后面是谁（其实就是线性表中前驱后继的概念），如同有一根线把他们串起来，这样的结构我们把它称之为线性表。 ...
2021-04-06 数据结构
Payforr的博客
04-06 261
2021-04-06数据结构 文章目录2021-04-06数据结构时间复杂度1.时间复杂度的计算规则线性结构1.线性结构存储方式的分类2.顺序表3.顺序表的结构4.链表的代码实现 时间复杂度 1.时间复杂度的计算规则 1、基本操作，认为其时间复杂度为O(1) sum = 100 + 200 sum = 2002+1002 2、顺序结构，时间复杂度按加法进行计算 第一步：a = 100 第二步：b = 200 第三步：c = a + b O(1) 3、循环结构，时间复杂度按乘法进行计算 for j in
《数据结构与算法》（十七）- 二叉排序树
程序园@大Null
11-15 1105
目录前言1. 二叉排序树1.1 二叉排序树的查找操作1.2 二叉排序树的插入操作1.3 二叉排序树删除操作1.4 二叉排序树总结2. 总结 前言 部分内容摘自程杰的《大话数据结构》 1. 二叉排序树   大家可能都听过这个故事，说有两个年轻人正在深山中行走。忽然发现远处有一只老虎要冲过来，怎么办？其中一个赶忙弯腰系鞋带，另一个奇怪地问：“你系鞋带干什么？你不可能跑得比老虎还快。” 系鞋带者说：“我有什么必要跑赢老虎呢？我只要跑得比你快就行了。”   这真是交友不慎呀！别急，如果你的朋友是系鞋带者，你怎么办
【2020-MOOC-浙江大学-陈越、何钦铭-数据结构】线性结构-线性表、堆栈与队列（第二周的笔记和编程作业）
种树最好的时间是10年前，其次是现在！！！
03-15 1831
文章目录〇、前言一、线性表1、线性表的顺序存储实现2、线性表的链式存储实现二、堆栈1、堆栈的定义与操作，顺序存储实现2、堆栈的定义与操作，链式存储实现三、队列1、队列的定义与操作，顺序存储实现2、队列的定义与操作，链式存储实现四、一元多项式的 加法与乘法运算五、课后题1、02-线性结构1 两个有序链表序列的合并 (15分)2、02-线性结构2 一元多项式的乘法与加法运算 (20分)3、02-线性结...
【数据结构】数据结构练习题5——查找+排序
xtcc的博客
01-05 6843
一、选择题 1.顺序查找法适合于存储结构为哪一种存储方式的线性表。（A） A 顺序存储或链接存储 B 散列存储 C 压缩存储 D 索引存储 2.对线性表进行二分查找时，要求线性表必须（A） A 以顺序方式存储，且结点按关键字有序排序 B 以顺序方式存储 C 以链接方式存储 D 以链接方式存储，且结点按关键字有序排序 3.对于查找表的查找过程中，若被查找的数据元素不存在，则把该数据元素插入到集合中。这种方式主要适合于（A） A 动态查找表 B 静态查找表 C 静态查找表与动态查找表 D 两种表都不适合 4.采
【数据结构(初稿)】线性表总结——基本知识要点汇总
bay_Tong桐小白的博客
06-28 6808
线性表的基本知识要点总结，包含线性表的相关概念；顺序表及单链表、循环单链表、双向链表、静态链表的工作原理、存储结构以及这些存储结构的基本操作集汇总
浙大PTA数据结构与算法题目集（中文）题解集复习用
qq_41342326的博客
08-26 1万+
7-1 最大子列和问题 (20分)（dp或贪心） 给定K个整数组成的序列{ N1, N2, …, N**K }，“连续子列”被定义为{ N**i, N**i+1, …, N**j }，其中 1≤i≤j≤K。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。 本题旨在测试各种不同的算法在各种数据情况下的表现。各组测试数据特点如下： 数据1
牛客刷题笔记--(数组专项练习1-77)
热门推荐
想握住此生辽阔
01-01 2万+
1 下面哪项是数组优于链表的特点？ D 方便删除 方便插入 长度可变 存储空间小 1： 数组内存空间少比链表少 2：数组支持随机访问，链表不具有随机访问的特性 3：插入和删除是链表优于数组，数组需要移动被删除或者插入位置之后的元素 https://blog.csdn.net/u014082714/article/details/44259029 D 链表要保存指向下个节点的指针，占用空间比数组更大 2 在C++中，以下定义和初始化的两数组a1和a2，那么下列说法正确的是( D)。 a1和a2完全相同
第4章：关于链表的二三事
入凡尘狼性不足
06-02 398
第四章 最基础的动态数据结构：链表 4-1 什么是链表 4-2 在链表中添加元素 4-3 使用链表的虚拟头结点 4-4 链表的遍历，查询和修改 4-5 从链表中删除元素 4-6 使用链表实现栈 4-7 带有尾指针的链表：使用链表实现队列 4-1 什么是链表 链表是一种非常重要的线性数据结构。 动态数组、栈、队列 => 这三者底层依托静态数组；靠resize解决固定容量问题 链表 => 真正的动态数据结构 为什么链表很重要？ 最简单的动态数据结构（还有二分搜索树、平衡二叉树等是更高级的动态数据
习题二-线性表
VIProgram的博客
12-20 7187
1.线性表（ a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂度为（ ） A、O（i） B、O（1） C、O（n） D、O（i-1） 正确答案：C 2.静态链表中指针表示的是（ ） A、内存地址 B、数组下标 C、下一元素地址 D、左、右孩子地址 正确答案：B 3.以下说法错误的是 ( ) A、对于线性表来
葵花宝典之数据结构1800T--2
loverz的专栏
09-09 3780
第2章    线性表 一  选择题 1．下述哪一条是顺序存储结构的优点？（    ）【北方交通大学 2001 一、4（2分）】 A．存储密度大  B．插入运算方便  C．删除运算方便  D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（    ）【北方交通大学 2001 一、14（2分）】 A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线
c语言listinsert函数怎么用,listinsert函数什么意思
weixin_36234970的博客
05-20 8870
int listinsert(sqlist * & L)中的&是什么意思void InitList(SqList &L) InitList 函数是初始化链表 前面 的& 是说 参说 L 是以 引用方式调用 初始化链表当然需要对参数做修改 应该使用引用或者指针形式的参数，引用形式的参数更加安全 引用形式的参数只有c++ 才可以 如果是在c程序里就要使listinser...
第3章 线性表
soulweee的博客
05-12 1155
第3章 线性表 线性表( List ):零个或多个数据元素的有限序列。 如果用数学语言来进行定义。可如下: 若将线性表记为(a1，…,a1，ai，a+1，…,an)，则表中a-1领先于a，a领先于 ai+1，称a1是 a的直接前驱元素，a+1是a的直接后继元素。当i=1，2，…,n-1时，a有且仅有一个直接后继，当i=2，3，…, n时,a有且仅有一个直接前驱。如图3-2-1所示。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。 3.1线性表的抽象数据类型 线性表的抽象数据类型定义如下: ADT
数据结构的ElemType
liangsena的博客
07-12 5875
关于数据结构教材中的ElemType说明。
二叉树常见递归算法
liangsena的博客
12-01 1042
目录1.统计二叉树中度为0，1，2 结点的个数2.统计二叉树的高度、宽度3.删除二叉树的所有叶子结点4.计算结点 *p 所在层次5.计算二叉树各结点的最大、最小元素的值6.交换二叉树中每个结点的两个子女7.先序输出二叉树中所有结点的数值及所层次 1.统计二叉树中度为0，1，2 结点的个数 2.统计二叉树的高度、宽度 3.删除二叉树的所有叶子结点 4.计算结点 *p 所在层次 5.计算二叉树各结点的最大、最小元素的值 6.交换二叉树中每个结点的两个子女 7.先序输出二叉树中所有结点的数值及所层次 ...
线性表-广义表（7.24）
liangsena的博客
07-24 833
广义表写在前面一、定义二、广义表长度三、深度四、存储结构写在最后 写在前面 这部分内容王道的课程没有介绍，先看了启航的，后对比看了新东方的，大同小异。 一、定义 一种非连续性的数据结构，是线性表的一种推广，通常记作 Ls=( a1，a2，…，ai，…，an) 一般来说，用大写字母表示广义表，用小写字母表示原子。通常用圆括号括起来，用逗号分隔其中的元素。 二、广义表长度 对广义表 Ls=( a1，a2，…，ai，…，an) 来说，n即为广义表的长度，我是去通过数逗号来看它的长度，也就是说： 例如， A=
线性表-队列（7.16）
liangsena的博客
07-21 279
文章目录写在最前一、队列的基本概念二、队列常见的基本操作三、队列的顺序存储3.1顺序队列3.2循环队列四、队列的链式存储结构五、双端队列小结 写在最前 一、队列的基本概念 队列：队列，简称队，也是一种受限的线性表，只允许在表的一端尽心插入，而在表的另一端进行删除。 队头：允许删除的一端，也称队首。 队尾：允许插入的一端。 空队列：不含任何元素的空表。 FIFO：先进先出。 二、队列常见的基本操作 InitQueue(&Q)：初始化队列，构造一个空队列Q。 QueueEmpty(Q)：判队列
谭浩强C语言数据结构-线性表与链式存储解析
在描述中提到了两种数据结构类型——线性表，包括静态线性表和动态线性表。线性表是一种最基本的数据结构，其中元素按照线性的顺序排列。静态线性表通常在内存中连续存储，大小固定，适用于元素数量预先知道的情况。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

森格的博

创作不易，感谢支持

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

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

打赏作者

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

抵扣说明：

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

余额充值