【数据结构与算法4】循环/双向链表及应用

最新推荐文章于 2025-05-20 17:19:00 发布
最新推荐文章于 2025-05-20 17:19:00 发布
阅读量186 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法基础 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_38800498/article/details/120224497
这篇博客介绍了线性表的三种实现方式：顺序表、双向链表和循环链表，并对比了它们的特性。重点讨论了线性表在合并操作上的实现，包括无序和有序线性表的合并。文中提供了C++代码示例，展示了如何使用顺序表合并无序和有序线性表，以及如何用链表实现有序线性表的合并。此外，还展示了一个用链表实现的多项式相加的例子，进一步阐述了线性表在实际问题中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 循环链表
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
  • 双向链表
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
  • 顺序表和链表的比较
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 线性表的应用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;
#define ElemType int
#define MAXSIZE 100
#include "windows.h"

//顺序表的数据结构
typedef struct {
    ElemType *data;//数组首元素的地址
    int length;
}SqList;

//初始化
void InitList(SqList &L)
{
    L.data = new ElemType[MAXSIZE];
    L.length = 0;
}

//打印线性表
void PrintList(const SqList &L)
{
    printf("输出顺序表的所有元素：");
    for (int i=0;i<L.length;i++)
    {
        printf("%d\t",L.data[i]);
    }
    printf("\n");
}

//创建线性表
void CreatList(SqList &L)
{
    int n;
    printf("请输入要输入的元素个数:");
    cin >> n;
    for (int i = 0;i<n;i++)
    {
        printf("请输入第%d个元素：",(i+1));
        cin >> L.data[i];
        L.length++;
    }
}

////合并两个无序线性表
//void MergeLise(SqList &La, SqList &Lb)
//{
//    int La_len = La.length;
//    int Lb_len = Lb.length;
//    int j = 0;
//    for (int i = 0;i < Lb_len;i++)
//    {
//        //遍历A，直到找到等于B.data[i]的元素或没找到才退出
//        while (La.data[j] != Lb.data[i] && j<La_len)
//        {
//            j++;
//        }
//        //没找到，则插入
//        if (j >= La_len)
//        {
//            La.data[La_len] = Lb.data[i];
//            La.length++;
//            La_len++;
//        }
//        j = 0;
//    }
//}

//顺序表的取值
int GetElem(SqList L,int i ,ElemType &e){
    if (i<0 || i>L.length){
        return -1;
    }
    else{
        e = L.data[i];
    }
    return 0;
}

//合并两个无序线性表
void MergeLise(SqList &La, SqList &Lb)
{
    int La_len = La.length;
    int Lb_len = Lb.length;
    ElemType e;
    for (int i = 0;i < Lb_len;i++)
    {
        int ret = GetElem(La,i,e);
        //没找到，则插入
        if (!ret)
        {
            La.data[La_len] = Lb.data[i];
            La.length++;
            La_len++;
        }
    }
}

int main() {
    SetConsoleOutputCP(CP_UTF8);
    SqList A,B;
    //初始化
    InitList(A);
    InitList(B);
    //创建
    CreatList(A);
    CreatList(B);
    //合并
    MergeLise(A,B);

    PrintList(A);
    PrintList(B);

    return 0;
}
  • 有序表的合并
    在这里插入图片描述
    在这里插入图片描述
  1. 用顺序表实现
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
#include <iostream>
using namespace std;
#define ElemType int
#define MAXSIZE 100
#include "windows.h"

//顺序表的数据结构
typedef struct {
    ElemType *data;//数组首元素的地址
    int length;
}SqList;

//初始化
void InitList(SqList &L)
{
    L.data = new ElemType[MAXSIZE];
    L.length = 0;
}

//打印线性表
void PrintList(const SqList &L)
{
    printf("输出顺序表的所有元素：");
    for (int i=0;i<L.length;i++)
    {
        printf("%d\t",L.data[i]);
    }
    printf("\n");
}

//创建线性表
void CreatList(SqList &L)
{
    int n;
    printf("请输入要输入的元素个数:");
    cin >> n;
    for (int i = 0;i<n;i++)
    {
        printf("请输入第%d个元素：",(i+1));
        cin >> L.data[i];
        L.length++;
    }
}

//合并两个有序线性表到C中

void MergeList(SqList A, SqList B, SqList &C)
{
    int i =0 ,j = 0,k = 0;
    int m = A.length;
    int n = B.length;

    while (i<m && j<n) {
        if (A.data[i] <= B.data[j]) {
            C.data[k] = A.data[i];
            C.length++;
            i++;
            k++;
        } else {
            C.data[k] = B.data[j];
            C.length++;
            k++;
            j++;
        }
    }
        while (i < m) //B已到达表尾，依次将A的剩余元素插人C的最后
        {
            C.data[k] = A.data[i];
            C.length++;
            i++;
            k++;
        }
        while (j < n) //B已到达表尾，依次将A的剩余元素插人C的最后
        {
            C.data[k] = B.data[j];
            C.length++;
            j++;
            k++;
        }

}


int main() {
    SetConsoleOutputCP(CP_UTF8);
    SqList A,B,C;
    //初始化
    InitList(A);
    InitList(B);
    InitList(C);
    //创建
    CreatList(A);
    CreatList(B);
    //合并
    MergeList(A,B,C);
    PrintList(C);
    return 0;
}
  1. 用链表实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
需要注意的是:因为链表结点之间的关系是通过指针指向建立起来的，所以用链表进行合并不需要另外开辟存储空间，可以直接利用原来两个表的存储空间， 空间复杂度为o(1)。
C与A共用一个头结点，只需改链即可！

#include <iostream>
using namespace std;
#define ElemType int
#define MAXSIZE 100
#include "windows.h"

////顺序表的数据结构
//typedef struct {
//    ElemType *data;//数组首元素的地址
//    int length;
//}SqList;
//单链表的数据结构
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//初始化
void InitList(LinkList &L)
{
    L = new LNode ;
    L->next = NULL;
}

//打印线性表
void PrintList(LinkList L)
{
    printf("输出单链表的所有元素：");
    LinkList p;
    p = L->next;
    while (p)
    {
        printf("%d",p->data);
        p = p->next;
    }
    printf("\n");
}

//尾插法 创建线性表
void CreatList(LinkList &L)
{
    int n;
    printf("请输入要输入的元素个数:");
    cin >> n;
    LinkList r = L;
    for (int i = 0;i<n;i++)
    {
        LinkList p = new LNode;
        printf("请输入第%d个元素",i+1);
        cin >> p->data;
        r->next = p;
        p->next = NULL;
        r = p;
    }
}

//合并两个有序线性表到C中
void MergeList(LinkList A,LinkList B, LinkList &C)
{
    LinkList pa = A->next;//pa指向A的第一个结点
    LinkList pb = B->next;//pb指向B的第一个结点
    C = A;                  //C指向A的头结点，共用
    LinkList pc = C;  //pc指向C的头结点即A的头结点
    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; //将非空表的剩余段插入到pc所指结点之后
    delete B;
}


int main() {
    SetConsoleOutputCP(CP_UTF8);
    LinkList A,B,C;
    //初始化
    InitList(A);
    InitList(B);
    InitList(C);
    //创建
    CreatList(A);
    CreatList(B);
    PrintList(A);
    PrintList(B);
    //合并
    MergeList(A,B,C);
    PrintList(C);
    return 0;
}
  • 案例分析与实现
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
#include <iostream>
using namespace std;
#define ElemType int
#define MAXSIZE 100
#include "windows.h"

//定义数据结构
typedef struct BookNode{
    int coef;
    int exp;
    struct BookNode*next;
}BookNode,*BookList;

//初始化
void InitBookNode(BookList &L)
{
    L = new BookNode;
    L->next = NULL;
}

//尾插法 创建多项式单链表
void CreatList(BookList &L, int n){
    BookList r;
    r = L;
    for (int i=0;i<n;i++)
    {
        BookList p = new BookNode ;
        printf("请输入第%d个项的系数：",i+1);
        cin >> p->coef;
        printf("请输入第%d个项的指数：",i+1);
        cin >> p->exp;
        r->next = p;
        p->next = NULL;
        r = p;
    }
}

//打印多项式
void PrintBook(BookList L)
{
    BookList p = L->next;
    while(p)
    {
        cout << p->coef << "*X^" << p->exp << "+" ;
        p = p->next;
    }
    cout << "0" << endl;
}

//多项式相加
void AddPoly(BookList &A , BookList &B, BookList &C)
{
    BookList pa = A->next;//pa指向A的第一个结点
    BookList pb = B->next;//pb指向B的第一个结点
    C = A;                  //C指向A的头结点，共用
    BookList pc = C;        //pc指向C的头结点即A的头结点
    while (pa && pb)
    {
        if (pa->exp < pb->exp)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        }
        else if (pa->exp > pb->exp)
        {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
        else//指数相等时
        {
            int x = pa->coef + pb->coef;
            if (x) //指数相等且系数和不为零时相加并保存到A节点,同时删除B节点
            {
                pc->next = pa;
                pc = pa;
                pc->exp = pa->exp;
                pc->coef = x;
                pa = pa->next;
                //删除B节点
                BookList pb_q = pb;
                pb = pb->next;
                delete pb_q;
            }
            else
            {
                BookList pa_q = pa;
                pa = pa->next;
                delete pa_q;
                BookList pb_q = pb;
                pb = pb->next;
                delete pb_q;
            }
        }
    }
    while(pa)
    {
        pc->next = pa;
        pc = pa;
        pa = pa->next;
    }
    while(pb)
    {
        pc->next = pb;
        pc = pb;
        pb = pb->next;
    }
}

int main() {
    SetConsoleOutputCP(CP_UTF8);
    BookList A,B,C;
    //初始化
    InitBookNode(A);
    InitBookNode(B);
    InitBookNode(C);
    //创建
    CreatList(A,4);
    CreatList(B,3);
    PrintBook(A);
    PrintBook(B);
    //合并
    AddPoly(A,B,C);
    PrintBook(C);
    return 0;
}


请输入第1个项的系数：7
请输入第1个项的指数：0
请输入第2个项的系数：3
请输入第2个项的指数：1
请输入第3个项的系数：9
请输入第3个项的
指数：8
请输入第4个项的系数：5
请输入第4个项的指数：17
请输入第1个项的系数：8
请输入第1个项的指数：1
请输入第2个项的系数：22
请输入第2
个项的指数：7
请输入第3个项的系数：-9
请输入第3个项的指数：8
7*X^0+3*X^1+9*X^8+5*X^17+0
8*X^1+22*X^7+-9*X^8+0
7*X^0+11*X^1+22*X^7+5*X^17+0

Process finished with exit code 0
【LLM】(KV cache优化)MHA、MQA、GQA、MLA、YOCO机制的区别
发现问题，并解决问题，批判性思维
02-16 3846
MHA机制（Multi-head Attention） MHA（Multi-head Attention）是标准的多头注意力机制，包含h个Query、Key 和 Value 矩阵。所有注意力头的 Key 和 Value 矩阵权重不共享 MQA机制（Multi-Query Attention） MQA（Multi-Query Attention，Fast Transformer Decoding: One Write-Head is All You Need）是多查询注意力的一种变体，也是用于自回归解码的一
大模型面经—GQA（Grouped Query Attention）和MHA、MQA的区别及代码
强化学习曾小健
07-08 2343
此外，GQA的实现并不复杂，可以通过对现有MHA模型进行少量的训练调整来实现，这使得从MHA到GQA的过渡相对容易。在大模型技术中，GQA（Grouped Query Attention）是一种注意力机制，它介于。之间进行插值，旨在实现更快的推理速度和接近MHA的模型质量，是高负载系统优化的有力工具。，最终将结果合并，以捕获序列的不同方面信息。具体来说，GQA通过分组的方式，减少了需要。的数量，从而减少了内存的使用，同时由于。2024年07月07日 10:43。）之间，旨在结合两者的优点，
大模型面试准备（五）：图解 Transformer 最关键模块 MHA
2201_75499313的博客
03-26 1508
节前，我们组织了一场算法岗技术&面试讨论会，邀请了一些互联网大厂朋友、参加社招和校招面试的同学，针对大模型技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何备战、面试常考点分享等热门话题进行了深入的讨论。合集在这里：《大模型面试宝典》(2024版) 正式发布！Transformer 原始论文中的模型结构如下图所示： 上一篇文章讲解了 Transformer 的关键模块 Positional Encoding（大家可以自行翻阅），本篇文章讲解一下 Transformer 的最重要模块 Multi-H
MHA(Multi-Head Attention) 与GQA(Grouped Query Attention)的区别
2301_79093491的博客
10-31 1085
特点：每个头都有独立的查询、键和值投影矩阵，最大化模型的表达能力。优点：能够捕获输入序列中丰富的特征，适用于对性能要求高的场景。缺点：参数量大，计算复杂度高，对资源要求较高。
2025大模型经典面试题，大模型面试题+答案！手撕面试官，八股文你不背不行！
2401_84204207的博客
03-20 1090
LangChain是一个用于构建和运行大型语言模型应用的开源框架。它提供了一套工具和组件，帮助开发者将大型语言模型（如 GPT-3）与其他工具和API结合，以完成更复杂的任务。1、LangChain包含哪些核心概念?Components:可重用的模块，例如API调用、数据库查询等。Chains:将多个Components链接在一起以完成特定任务的流程。Prompt Templates: 用于指导语言模型生成输出的文本模板。Output Parsers:解析语言模型输出的工具。
MHA、MQA、GQA、MLA
qq_38781359的博客
03-11 2395
方法QK/V计算效率模型容量MHA每个头独立每个头独立低高MQA每个头独立全局共享高低GQA每个头独立组内共享中中MQA适合推理加速（如 LLama-2 70B 使用 MQA）。GQA在保持较高性能的同时减少计算（如 LLama-3 使用 GQA）。MHA适用于对性能要求极高的场景。
理解 MHA、GQA、MQA 和 MLA：多头注意力的变种及其应用
lqq
02-25 2669
在深度学习、自然语言处理（NLP）和计算机视觉（CV）中，多头注意力（Multi-Head Attention, MHA）是 Transformer 结构的核心。近年来，MHA 产生了多个变体，如和，这些改进主要用于提高计算效率和减少计算开销。本文将深入探讨这些注意力机制的工作原理、数学公式、优缺点及应用场景，帮助理解Transformer 及其改进版本。
从MHA、MQA、GQA到MLA
步子哥的博客
08-18 1186
尤其是在长上下文的情况下，KV Cache的大小会随着输入长度的增加而增长，从而影响了模型的推理速度和资源消耗。通过对MHA、MQA、GQA和MLA的分析，我们可以看到，随着技术的发展，模型设计不断优化，以应对现实应用中的各种挑战。这篇文章详细介绍了从MHA到MLA的演变过程，强调了在推理过程中缓存的重要性，以及如何通过不同的模型设计来减少缓存的需求。，显著降低了显存的占用。在推理阶段，MLA通过共享K和V的方式，将KV Cache的大小保持在合理范围内，从而避免了MHA带来的显存瓶颈。
缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA
Paper weekly
05-18 5349
©PaperWeekly 原创 ·作者 | 苏剑林单位 | 科学空间研究方向 | NLP、神经网络前几天，幻方发布的 DeepSeek-V2[1] 引起了大家的热烈讨论。首先，最让人哗然的是 1 块钱 100 万 token 的价格，普遍比现有的各种竞品 API 便宜了两个数量级，以至于有人调侃“这个价格哪怕它输出乱码，我也会认为这个乱码是一种艺术”；其次，从模型的技术报告看，如此便宜的价格背...
理解Attention，MHA、MQA、GQA理论知识和代码实现
yangyanbao8389的博客
07-03 1006
【代码】理解Attention，MHA、MQA、GQA理论知识和代码实现。
MLA, MQA 和 GQA 区别和联系
强化学习曾小健
01-25 996
GQA 是对Multi-Head Attention (MHA) 和 MQA的扩展，通过将查询头分为多个组来共享键（K）和值（V）投影，从而提高计算效率并降低内存开销。每个组中的查询共享同一组 K 和 V，这样可以减少模型的参数数量和内存需求。
大模型学习-GQA、MQA、MHA
fj1024的博客
07-16 790
而每个注意力头都有自己的感知域，可以独立学习输入中的不同特性。事实上，不同的”头“可以分别专注于词序列的不同方面，语义、语法。从 MHA 到 MQA 将 H 键和值头减少到单个键和值头，减少了键值缓存的大小，因此需要加载的数据量 H 倍。MQA是MHA的变体，不同的是MQA让所有的头之间共享同一份Key和Value矩阵，每个头只单独保留一份query参数，从而大大减少了Key和Value矩阵的参数量，以此达到提升推理速度，但是会带来精度的损失。注意力机制的核心概念在于把不同的重要性赋予输入的不同部分。
手撕大模型Attention：MLA、MHA、MQA与GQA（含实现代码）
最新发布
Datawhale
05-20 535
是对多头注意力（MHA）和多查询注意力（MQA）的折中优化方案。其核心思想是将查询头（Query Heads）划分为多个组（Group），每组内的查询头共享一组键（Key）和值（Value），从而在保留多头并行性的同时减少参数量和计算复杂度。多头注意力（Multi-Head Attention, MHA）是Transformer模型的核心机制，通过并行计算多个注意力头，使模型能够同时关注输入序列中不同位置的特征。这种设计在保持多头多样性的前提下，减少了显存占用和计算延迟，适合长序列建模和大规模模型部署。
TensorFlow相关组件的安装
AAI666666的博客
01-11 2935
TensorFlow相关组件的安装
算法手撕面经系列(1)--手撕多头注意力机制
罟霖同学的站点
09-13 1685
手动实现多头注意力机制
深度学习中的注意力机制：MHA、MQA和GQA
bbbeoy的专栏
07-12 677
深度学习中的注意力机制：MHA、MQA和GQA
大模型推理——MLA实现方案
weixin_43507865的博客
02-08 1081
MLA
DeepSeek开源AI模型：智能校园的未来与技术革新
资源摘要信息:"DeepSeek革新：突破边界的AI技术与‘浙大先生’的智慧校园愿景" 知识点详细说明： 1. DeepSeek开源AI模型： DeepSeek是一款开创性的开源人工智能模型，它在AI技术领域取得了重大突破。通过采用多项...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

姬霓钛美

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

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

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

打赏作者

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

抵扣说明：

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

余额充值