数据结构（学习笔记）（线性表）

已于 2023-05-02 12:19:31 修改
阅读量152 收藏
点赞数 2
文章标签： 学习 数据结构 笔记 c#
于 2023-05-02 12:13:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75051861/article/details/130449298
版权

说明：

学习内容根据b站王卓老师视频学习记录
参考地址第02周08--2.4线性表的顺序表示和实现3_哔哩哔哩_bilibili

目录

1. 线性表

顺序表

 链表

线性表的应用

1. 线性表

顺序表

在写代码之前可以做一些简单的定义（方便解读）

#define LIST_MAX 100            //多项式可能达到的最大长度
#define OVERFLOW -2
#define OK 1
#define ERROR 0

typedef int Status;
typedef char ElemType;

 存储结构：

1.静态定义：

//确定存储空间（静态分布）
typedef struct{
    int elem[LIST_MAX];               //存储存储地址
    int length;                //线性表的当前长度
}SqList;                //顺序表类型

2.动态定义

//指针的形式（动态分布）
typedef struct{
    int *elem;              //指向存储地址
    int length;                //顺序表的当前长度
}SqList;                //顺序表类型

动态定义因为没有直接定义线性表的存储空间，所以在使用时（初始化时要动态分配存储空间）引用如下形式的代码：

SqList L;
L.data = (ElemType *)malloc(sizeof(ElemType)*LIST_MAX);

 补充：
        多项式非零项的定义（动态分布）：

//多项式非零项的定义
typedef struct{
    float p;            //系数
    int e;              //指数
}Polynomial;

typedef struct{
    Polynomial *elem;           //存储空间的基地址
    int length;                 //当前项的个数
}SqList;                //多项式的顺序存储结构类型为SqList

 初始化：（以动态分布为例子）

//线性表的初始化(参数引用引用)
Status InitList(SqList &L){               //构建一个空的顺序表
    L.elem = new int[LIST_MAX];
    if (!L.elem)
        return OVERFLOW;
    L.length = 0;
    return OK;
}

顺序表的基本简单操作：
        （销毁、清空、求长度、判断是否为空）的相关操作

//销毁线性表L
void DestoryList(SqList &L){
    if (L.elem)
        delete L.elem;              //释放存储空间
}

//清空线性表
void ClearList(SqList &L){
    L.length = 0;               //将线性表的长度置为0
}

//求线性表的长度
int GetLength(SqList &L){
    return (L.length);
}

//判断线性表L是否为空
int IsEmpty(SqList &L){
    if(L.length == 0){
        return 1;
    } else{
        return 0;
    }
}

   顺序表的基本操作：

    顺序表的取值：
        在顺序表L中获取i位置的数据，并用e来返回获取到的元素；

//线性表（顺序表）的取值（根据位置i获取相应位置数据元素的内容）
int GetElem(SqList L,int i,ElemType &e){
    if (i<1 || i>L.length)
        return ERROR;               //判断i位置是否合理，不合理返回ERROR
    e = L.elem[i-1];                //第i-1个位置存储着第i个数据
    return OK;
}

  顺序表的查找：
         查找顺序表L中数据和e相等的元素，如果查找成功则返回其序号，若没有查找 到则返回0；

//顺序表的查找
int LocateElem(SqList L,ElemType e){
    //在线性表L中查找值为e的数据元素，返回其序号（是第几个元素）
    for (int i = 0; i < L.length; ++i) {
        if (L.elem[i] == e)
            return i+1;                 //查找成功，返回序号
        return 0;               //查找失败，返回0
    }
}

顺序表的插入：
        在顺序表L中第i位置处插入数据e；

//顺序表的插入
Status ListInsert(SqList &L,int i,ElemType e){
    if(i<1 || i>L.length+1)
        return ERROR;               //i值不合法
    if (L.length == LIST_MAX)
        return ERROR;               //当前存储空间已经满了

    for (int j=L.length-1; j>=i-1; ++j) {
        L.elem[j+1] = L.elem[j];                //插入位置及之后的元素后移
    }

    L.length++;                //表长增加1
    return OK;
}

顺序表的删除：
        在顺序表L中删除第i位置处的元素；

//线性表的删除
Status ListDelete(SqList &L,int i){
    if (i<1 || (i>L.length)){
        return ERROR;               //i值不合法
    }

    for (int j=i; j<=L.length; ++j) {
        L.elem[j-1] = L.elem[j];                //被删除的元素之后的元素前移
    }

    L.length--;             //表长减1
    return OK;
}

 链表

单链表
        理解概念：节点只有一个指针域的链表。

        无头节点时空表：头指针指向空；
        有头节点的空表：头节点的指针域为空。

        头节点的好处：在插入、删除等操作时不需要特殊处理。

        顺序表采用的是随机存取，链表采用的是顺序存取。

存储结构

//单链表的存储结构
typedef struct Lnode{
    ElemType data;              //结点的数据域
    struct Lnode *next;             //结点的指针域
}Lnode,*LinkList;               //LinkList为指向结构体Lnode的指针类型

        使用*LinkList的好处：在定义链表时可以直接定义LinkList L，等价与Lnode *L；
                                            同时在定义结点指针p时：可以直接写LinkList p，等价于Lnode *p；

初始化：
        建立一个空表

//单链表的初始化
Status InitList(LinkList &L){
    L = new Lnode;              //c++语言
    //或L = (LinkList)malloc(sizeof(Lnode));         //c语言
    L->next = NULL;
    return OK;
}

 单链表的基本操作的实现：

         判断链表是否为空：
                如果为空就返回1，不为空返回0。

//判断链表是否为空
int ListEmpty(LinkList L){
    if (L->next){               //非空
        return 0;
    } else{
        return 1;
    }
}

         链表的销毁：
                从头结点开始依次释放所有结点。

//单链表的销毁
Status DestroyList(LinkList &L){
    Lnode *p;               //或LinkList p;
    while (L){
        p = L;
        L = L->next;
        delete p;
    }
    return OK;
}

         清空单链表：
                链表中除头指针和头节点其他清空。

//清空单链表
Status ClearList(LinkList &L){
    Lnode *p,*q;                //或LinkList p,q;
    p = L->next;

    while (p){              //没到表尾
        q = p->next;
        delete p;
        p = q;
    }
    L->next = NULL;             //头节点指针域为空
}

         求单链表的表长：
                从首元节点开始，依次计数所有的结点。

//求单链表的表长
Status ListLength(LinkList L){
    Lnode *p;               //或LinkList p;
    int count = 0;              //记录长度
    p = L->next;

    while(p){               //遍历求单链表的长度
        count++;
        p = p->next;
    }
    return count;
}

         取值：
                取单链表中第i位置的元素并用e返回。

//取值
Status GetElem(LinkList L,int i,ElemType &e){
    Lnode *p;
    p = L->next;                //初始化
    int j=1;

    while (p && j<i){               //向后扫描，直到p指向第i个元素或p为空
        p = p->next;
        j++;
    }

    if (!p || j>i){             //第i个元素不存在
        return ERROR;
    }

    e = p->data;                //取第i个元素
    return OK;
}

         查找：
                1.根据指定的数据获取该数据所在的位置（地址）。

//查找
Lnode *LocateList(LinkList L,ElemType e){
    Lnode *p;
    p = L->next;

    while(p && p->data != e){
        p = p->next;
    }
    return p;
}

                2.根据指定数据获取该数据位置序号。

//查找（序号）
int LocateList(LinkList L,ElemType e){
    Lnode *p;
    p = L->next;
    int i = 1;

    while(p && p->data!=e){
        p = p->next;
        i++;
    }
    
    if (p){                 //在单链表中找到e
        return i;
    } else{                 //在单链表中没有找到（失败）
        return 0;
    }
}

         插入：
                在第i个结点前插入值为e的结点。

Status ListInsert(LinkList &L,int i,ElemType e){
    Lnode *p;
    p = L;
    int j = 0;              //用来记录指针的位置

    while (p && j<j-1){             //循环寻找第i-1个结点，并使p指向i-1结点
        p = p->next;
        j++;
    }

    if (!p || j>i-1)                //i大于表长+1或者小于1，插入位置非法
        return ERROR;
    else{
        Lnode  *s = new Lnode;               //建立新节点
        s->data = e;
        s->next = p->next;
        p->next = s;
        return OK;
    }
}

         删除：
                删除第i个结点。

//删除
Status DeleteList(LinkList &L,int i,ElemType &e){
    Lnode *p;
    p = L;                //p指向链表L的头结点
    int j = 0;

    while(p->next && j<i-1){                //寻找第i个结点，并使p指向其前驱
        p = p->next;
        j++;
    }

    if (!(p->next) || j>i-1)                //位置不合理
        return ERROR;
    else{
        Lnode *q = p->next;             //创建q指针指向p->next;方便表示p->next->next
        p->next = q->next;
        e = q->data;
        delete q;               //释放删除结点的空间
        return OK;
    }
}

         单链表的建立：
                        头插法：元素插入到链表的头部

//链表的建立（头插法）
void CreateList(LinkList &L,int n){
    L = new Lnode;              //或L = (LinkList)malloc(sizeof(Lnode))
    L->next = NULL;             //先建立一个带头结点的单链表

    for (int i = n; i > 0; --i) {
        Lnode *p = new Lnode ;             //生成新结点p=(Lnode *)malloc(sizeof(Lnode((
        cin>>p->data;               //输入元素值 scanf(&p->data);(c语言)
        p->next = L->next;              //插入到表头
        L->next = p;
    }
}

                        尾插法： 元素插入在链表尾部。

//链表的建立（头插法）
void CreateList(LinkList &L,int n){
    L = new Lnode;              //或L = (LinkList)malloc(sizeof(Lnode))
    L->next = NULL;             //先建立一个带头结点的单链表

    for (int i = n; i > 0; --i) {
        Lnode *p = new Lnode ;             //生成新结点p=(Lnode *)malloc(sizeof(Lnode((
        cin>>p->data;               //输入元素值 scanf(&p->data);(c语言)
        p->next = L->next;              //插入到表头
        L->next = p;
    }
}

 循环链表：一种头尾相连的链表（最后一个结点的指针指域向头结点）

        判断链表为空：判断最后一个结点的指针域是否指向头结点。(p->next!=L)

        带尾指针循环链表的合并：

//循环链表的合并
//假设Ta、Tb都是非空的单循环链表
LinkList Connect(LinkList Ta,LinkList Tb){
    Lnode *p = Ta->next;                //p存表头结点
    Ta->next = Tb->next->next;              //Tb表头连接Ta表尾
    delete Tb->next;                 //释放Tb表头结点
    Tb->next = p;                   //修改指针
    return Tb;
}

双链表
        理解概念：节点有两个指针域的链表。

        存储结构：

//双向链表结构定义
typedef struct DuLNode{
    ElemType data;
    struct DuLNode *prior,*next;
}DuLNode,*DuLinkList;

         在双链表中：p->next->prior = p = p->prior->next;

        双向链表的插入：
                在带头结点的双向循环链表L中第i位置之前插入元素e。

//双向链表的插入
//在带头结点的双向循环链表L中第i位置之前插入元素e
Status ListInsert(DuLinkList &L,int i,ElemType e){
    DuLNode *p;
    if (!(p=GetElem(L,i)))              //GetElem(L,i)得到双向链表的第i个位置元素的地址(伪代码)
        return ERROR;
    DuLNode *s = new DuLNode;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;
    return OK;
}

        双向链表的删除：
                删除带头结点的双向链表L的第i个元素，并用e返回。

//双向链表的删除
//删除带头结点的双向链表L的第i个元素，并用e返回。
Status ListDelete(DuLinkList &L,int i,ElemType &e){
    DuLNode *p;
    if(!(p = GetElem(L,i)))             //GetElem(L,i)得到双向链表的第i个位置元素的地址(伪代码)
        return ERROR;

    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete(p);
    return OK;
}

线性表的应用

 线性表的合并：(无序)

步骤：

  1. 分别获取LA表以及LB表的长度n，m。

  2. 从LB中第一个数据开始，循环n次执行以下操作：

    • 从LB中查找第i个数据元素赋值给e；

    • 在LA中查找元素e，如果不存在，将e插在表LA后。

//线性表的合并
void Union(SqList &La,SqList &Lb){
    int La_len = GetLength(La);
    int Lb_len = GetLength(Lb);
    ElemType e;

    for (int i = 1; i <= Lb_len; ++i) {
        GetElem(Lb,i,e);
        if (!LocateElem(La, e)) {
            ListInsert(La, ++La_len, e);
        }
    }
}

有序表的合并：

        顺序表实现：(代码在定义指针时会有报错，当然也可以不用指针去做）

算法步骤：

  • 创建一个表长为m+n的空表LC

  • 指针pc初始化，指向LC的第一个元素。

  • 指针pah和pb初始化分别指向LA和LB的第一个元素。

  • 当指针pa和pb均未到达相应表尾时，则依次比较pa和pb所指向的元素值，从LA或LB摘取元素值较小的节点插入LC的最后。

  • 如果pb已将到达LB的表尾，依次将LA的剩余元素插入LC的最后。

  • 如果pa已将到达LA的表尾，依次将LB的剩余元素插入LC的最后。

//有序表的合并——顺序表实现
void MergeList(SqList LA,SqList LB,SqList &LC){
    SqList *pa,*pb,*pc,*pa_last,*pb_last;               //创建几个指针(此处为自己创建，下文会有报错,原视频无定义)
    pa = LA.elem;
    pb = LB.elem;               //指针pa，pb的初始值分别指向两个表的第一个元素

    LC.length = LA.length + LB.length;
    LC.elem = new ElemType[LC.length];              //为合并后的新表分配一个数组空间

    pc = LC.elem;               //指针pc指向新表的第一个元素

    pa_last = LA.elem + LA.length-1;                //指针pa_last指向LA表的最后一个元素
    pb_last = LB.elem + LB.length-1;                //指针pb_last指向LB表的最后一个元素

    while (pa<=pa_last && pb<=pb_last){             //两个表都为非空
        if (*pa<=*pb)               //依次“摘取”两表中值较小的结点
            *pa++=*pa++;
        else
            *pc++ =*pb++;
    }

    while (pa<= pa_last)
        *pa++ = *pa++;              //LB表已经到达表尾，将LA中剩余元素加入LC
    while (pb<=pb_last)             //LA表已经到达表尾，将LB中剩余元素加入LC
        *pc++ = *pb++;
}

        有序表合并：用链表实现
                （相比顺序表的指针创建相对简单的多）

//有序表的合并——用链表实现
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){
    Lnode *pa,*pb,*pc;
    pa = La->next;
    pb = Lb->next;
    pc = Lc = La;               //用La的头结点作为Lc的头结点

    while(pa && pb){                //谁小谁在前
        if (pa->data <=pb->data){
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        } else{
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }

        pc->next = pa?pa:pb;                //插入剩余段
        delete Lb;              //释放Lb的头结点
    }
}

第一章完结

有木子的小赵
关注
数据结构学习笔记.docx
11-26
数据结构是计算机科学中的核心概念，...以上就是数据结构学习笔记的主要内容，涵盖了时间复杂度、空间复杂度、线性表、栈、队列、字符串、数组和矩阵等核心概念。理解并掌握这些知识对于深入学习计算机科学至关重要。
单链表的常用算法
kxbdys的博客
03-30 5273
一、判断链表是否为空 1、空表：链表中无元素，称为空链表，但头指针和头节点仍然存在。 2、算法思路：判断头结点的指针域是否为空。 int ListEmpty(LinkList L){ //若L为空表，则返回1，否则返回0 if(L->next) //非空 return 0; else return 1; } ...
软考数据结构基础学习笔记
04-02
「数据结构基础学习笔记」 本笔记将为您详细介绍数据结构的基础知识，包括线性表、栈、队列、串和KMP算法等内容。 一、线性表 线性表是n个元素的有限序列，通常记为(a1，a2，…，an)。特点是：(1)存在惟一的表头...
考研数据结构-学习笔记
05-17
综上所述，线性结构是数据结构的基础，通过对线性表、栈、队列等的理解，可以为后续更复杂的非线性结构的学习打下坚实的基础。在实际应用中，根据问题的具体需求选择合适的存储方式和操作方法至关重要。
数据结构学习笔记（王道）
12-29
数据结构是计算机科学中至关...总结来说，数据结构和算法的学习对于理解计算机科学的核心原理至关重要，它们为高效编程和优化解决方案提供了理论基础。无论是考研准备还是实际开发工作，掌握这些知识点都是必不可少的。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 839
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
计算几何学习
网安小白
09-12 443
学习计算几何过程中对经典算法的记录
看Threejs好玩示例，学习创新与技术(二)
htsitr2的专栏
09-14 478
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
09-11 924
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
【学习笔记】SSL密码套件之哈希
Taki_UP的博客
09-12 1154
本篇介绍了TLS/SSL密码套件中常用的哈希算法，包括Poly1305、SHA384、SHA256、SHA、MD5
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 467
继续学习头文件的数学函数。
区块链学习笔记2--区块链技术的形成 以太坊
weixin_61074128的博客
09-10 418
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 872
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
java开发中间件学习记录（持续更新中~）
m0_74969835的博客
09-14 1296
Java,Springboot,Springcloud,Redis,Mysql,Rabbitmq,Jvm,Juc等等
多线程学习篇二：Thread常见方法
好记性不如烂笔头
09-14 565
Java 中线程状态有6个，分别为:NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED。t1 是非守护线程， t2 是守护线程，当 t1 执行完 JVM 中不存在非守护线程，即使 t2 未执行完，也会退出 JVM。运行到 t1 的 join 方法时，t1 运行结束，t2 已运行 1s，所以还需要等到 1s 就可以运行完毕。运行结果：通过打印日志的时间戳，我们可以看出来，如果一个线程的打断标记为 true，则 park 失效。
IIC基本学习
????????????????????????????????????????????????
09-11 259
对IIC通信协议补充了基本的了解，在进行相关的工程实践后再进行补充。
ARM驱动学习之1Module
最新发布
JT Blog
09-15 202
ARM驱动学习之1Module mini_linux_module.c: #include <linux/init.h> #include <linux/module.h> MODULE_LICENSE("Dual BSD/GPL"); MODULE_AUTHOR("TOPEET"); stat...
24.9.14学习笔记
m0_64006292的博客
09-14 635
Fast R-CNN通过将分类和边界框回归整合进一个网络中，大大减少了训练时间和推理时间，同时也提高了检测的准确性。它的引入标志着目标检测领域的一大进步，也为后续的研究提供了重要的基础。尽管如此，Fast R-CNN仍然依赖外部的候选区域生成方法，直到Faster R-CNN的出现，才实现了候选区域生成的端到端学习。SSD（Single Shot MultiBox Detector）是一种流行的目标检测算法，它能够在一次前向传递中同时完成物体分类和位置回归，从而实现了实时检测的能力。
sheng的学习笔记-AI-FOIL(First-Order Inductive Learner)
coldstarry的专栏
09-14 399
AI目录：sheng的学习笔记-AI目录-CSDN博客规则学习（rule learning）: sheng的学习笔记-AI-规则学习（rule learning）-CSDN博客序贯覆盖(sequential covering):sheng的学习笔记-AI-序贯覆盖(sequential covering)FOIL(First-Order Inductive Learner)是著名的一阶规则学习算法，它遵循序贯覆盖框架且采用自顶向下的规则归纳策略，与命题规则学习过程很相似。但由于逻辑变量的存在，FOIL在规则
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值