单链表专题（二）-刷题复盘篇：四道经典题踩坑记录+多思路对比

原创 已于 2026-08-13 01:25:30 修改 · 333 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
数据结构 # 数据结构 | 学习与刷题笔记

当前文章被收录于：

数据结构 # 数据结构 | 学习与刷题笔记
23 篇文章 0 人学习

以课堂学习与练习实战为线索，从线性表、栈队列等基础结构到进阶内容，逐步梳理核心逻辑，附手写代码实现，夯实算法思维与编程能力。

订阅专栏 查看详情
于 2026-08-06 00:47:15 首次发布

写在前面

承接上篇的三道基石题，最近继续刷了四道链表与数组的高频题，从数组原地合并到链表反转、归并、分割，核心都围绕双指针思想展开，但每道题都踩了实打实的坑。这篇把我的最终写法、踩过的真实坑点、以及其他可行思路一起整理出来，既是个人复盘，也做思路拓展。

上篇回顾：单链表专题（应用篇）：三道经典题吃透删除、反转与快慢指针

本文章代码仓库位置（具体说明和使用方法在模块六仓库说明）

数据结构/单链表专题二（刷题复盘篇）：四道经典题踩坑记录+多思路对比 · Luminous/Code_2026 - 码云 - 开源中国

一、合并两个有序数组（LeetCode 88）

题目描述

给你两个按非递减顺序排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和 nums2中的元素数目。请你合并nums2到nums1中，使合并后的数组同样按非递减顺序排列。

注意：nums1的初始长度为m+n，前m个是有效元素，后n个为0占位；最终结果直接存放在nums1 中，不需要返回值。

示例：输入：nums1 = [1,2,3,0,0,0], m=3 , nums2 = [2,5,6] ,n = 3输出：[1,2,2,3,5,6]

题意分析

这道题本质是数组版的归并排序合并步骤，但约束很明确：必须原地合并，不能开额外结果数组。 最开始我本能照搬链表归并的思路，想从前向后双指针遍历，很快就发现问题：nums1前面的有效元素会被写入的值覆盖，数据直接丢失。所以最优解一定是从后往前倒着填，利用尾部的空闲空间，谁大放谁，完全不会影响前面的有效数据。

我的写法：三指针从后向前归并

用三个下标分别指向nums1有效末尾、nums2末尾、nums1整体末尾，循环比较取大值写入，最后单独处理nums2的剩余元素。

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int l1 = m - 1;
    int l2 = n - 1;
    int l3 = m + n - 1;
    
    while((l1 >= 0) && (l2 >= 0))
    {
        if(nums1[l1] < nums2[l2])
        {
            nums1[l3] = nums2[l2];
            l3--;
            l2--;
        }
        else
        {
            nums1[l3] = nums1[l1];
            l1--;
            l3--;
        }
    }
    while (l2 >= 0)
    {
        nums1[l3] = nums2[l2];
        l2--;
        l3--;
    }
}

我踩过的坑

  1. 思维惯性坑：一开始直接套链表归并的“从前向后双指针”，写了两行才反应过来数组是连续内存，向前写会覆盖未读取的有效数据，这也是数组和链表归并最核心的区别。
  2. 多余操作误区：循环结束后还补了一段处理l1剩余的循环，写完才反应过来：nums1剩下的元素本来就在数组前部，本身就在正确位置，完全不需要额外移动。
  3. 边界忽略：一开始没特意考虑m=0的场景，也就是nums1全是占位0、所有元素都要从 nums2迁入；幸好第二个while循环天然覆盖了这个情况，没有出问题。

其他可行思路

  1. 暴力排序法：把nums2的元素全部复制到nums1后半段的空位，直接对整个nums1做一次排序。思路零门槛，完全不用设计指针逻辑，缺点是时间复杂度高，属于“想不出最优解时的保底写法”。
  2. 辅助数组法：新开一个长度为m+n的临时数组，两个指针从前向后正常归并写入，最后再整体拷贝回nums1。逻辑和链表归并完全一致，最好理解，缺点是占用额外空间，不符合原地合并的进阶要求。

二、反转链表（LCR 024）

题目描述

给你单链表的头节点head，请你反转链表，并返回反转后的链表头节点。

提示：

  • 链表中节点的数目范围是[0, 5000]
  • -5000 <= Node.val <= 5000

题意分析

这是链表题的“基本功天花板”，后续很多进阶题都会把反转当作子步骤调用。核心本质就是把每个节点的next指针，从指向后继改为指向前驱。我选了最稳妥的迭代双指针写法，全程原地修改指针，空间复杂度O(1)，也没有递归栈溢出的风险。

我的写法：双指针迭代原地反转

用前驱指针和当前指针逐步推进，每次修改指向前先保存后继节点，避免断链。

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head){
    ListNode* pcur = head;
    ListNode* next;
    ListNode* store = NULL;

    while(pcur != NULL)
    {
        next = pcur->next;
        pcur->next = store;
        store = pcur;
        pcur = next;
    }
    return store;
}

我踩过的坑

  1. 经典断链坑：最开始写的时候手快，先改了pcur->next再去取下一个节点，直接把后半段链表弄丢了，遍历当场中断。链表操作铁则：改next之前，一定先存好后继节点。
  2. 返回值搞反：第一次写完下意识返回了pcur，结果直接返回空。循环结束时pcur已经走到了NULL，store才停在原链表最后一个节点，也就是反转后的新头。
  3. 认知误区：一开始以为反转要新建节点、拷贝数值，后来才明白只需要改指针指向，节点本身完全可以复用，空间开销直接从O(n)降到O(1)。

其他可行思路

  1. 递归反转法：核心思想是“先递归反转后面的子链表，再把当前节点接到子链表的尾部”。代码写出来非常精简，不需要手动管理多个指针，但理解门槛更高，链表过长时还会有递归栈溢出的风险。
  2. 新链表头插法：遍历原链表的每个节点，每次都把当前节点插到新链表的最头部，遍历完成后天然就是反转后的链表。和迭代法本质原理一致，只是表述和操作视角不同。

三、合并两个有序链表（LeetCode 21）

题目描述

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

提示：

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按非递减顺序排列

题意分析

这就是链表版的归并合并，和第88题是同一套思想，区别只在于数组操作下标、链表操作指针。我采用的是虚拟头节点+尾插法，也是个人认为最不容易写错、边界最少的写法。

我的写法：虚拟头+双指针尾插

新建一个哨兵节点当临时头，游走指针负责尾部拼接，两个链表同步遍历，谁小接谁，最后接上剩余部分。

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    ListNode* head1 = list1;
    ListNode* head2 = list2;
    ListNode* dummy = (ListNode*)malloc(sizeof(ListNode));
    ListNode* cur = dummy;

    while((head1 != NULL) && (head2 != NULL))
    {
        if(head1->val < head2->val)
        {
            cur->next = head1;
            head1 = head1->next; 
        }
        else
        {
            cur->next = head2;
            head2 = head2->next; 
        }
        cur = cur->next;
    }
    cur->next = head1 != NULL ? head1 : head2;

    ListNode* Res = dummy->next;
    free(dummy);
    return Res;
}

我踩过的坑

  1. 致命低级坑：第一次写完返回了cur->next而不是dummy->next。cur到最后已经走到了链表尾部，cur->next只是后半段剩余节点，前面的所有节点直接全部丢失，这个bug排查了很久。记住：虚拟头的next才是新链表真正的头。
  2. 内存困惑：纠结过malloc的哨兵要不要free、free后要不要把指针置NULL。刷题场景下不 free也能AC，但工程代码必须配对释放；至于free后置NULL，因为函数马上就要返回、局部变量立刻销毁，这里置空属于多余操作，没有实际意义。
  3. 走弯路：最开始想新建节点拷贝val来拼接，后来发现完全可以直接复用原链表节点，只改 next指针，不用额外申请业务节点。

其他可行思路

  1. 递归合并法：每次比较两个链表的头节点，把值更小的作为结果头，它的next指向剩下两个链表的递归合并结果。不用虚拟头，代码极精简，但同样有递归栈开销，链表很长时不推荐。
  2. 无虚拟头直接拼接：先单独比较选出新的头节点，再用指针向后遍历逐个拼接。省掉了一个哨兵节点的malloc，但要单独处理头节点的边界情况，代码分支更多，反而更容易写错。

四、分割链表（面试题 02.04）

题目描述

给你一个链表的头节点head和一个特定值x，请你对链表进行分隔，使得所有小于x的节点都出现在大于或等于x的节点之前。不需要保留每个分区中各节点的初始相对位置。

提示：

  • 链表中节点的数目在范围[0, 200]内
  • -100 <= Node.val <= 100
  • -200 <= x <= 200

题意分析

这道题是我踩坑最多的一道，从审题到指针操作再到边界处理，踩了个遍。核心思路很直观：一条链存小于x的节点，一条链存大于等于x的节点，遍历一遍分组，最后把两条链拼起来。

我的写法：双虚拟头+尾插分组

两个哨兵分别管理两部分链表，尾插法逐个接入节点，最后拼接并切断大链表尾部防止成环。

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x)
{
    ListNode* dummy_small = (ListNode*)malloc(sizeof(ListNode));
    ListNode* dummy_large = (ListNode*)malloc(sizeof(ListNode));
    dummy_small->next = NULL;
    dummy_large->next = NULL;

    ListNode* cur_small = dummy_small;
    ListNode* cur_large = dummy_large;
    ListNode* cur = head;

    while(cur != NULL)
    {
        if(cur->val < x)
        {
            cur_small->next = cur;
            cur_small = cur_small->next;
        }
        else
        {
            cur_large->next = cur;
            cur_large = cur_large->next;
        }
        cur = cur->next;
    }
    cur_large->next = NULL;
    cur_small->next = dummy_large->next;

    ListNode* res = dummy_small->next;
    free(dummy_small);
    free(dummy_large);
    return res;
}

我踩过的坑

  1. 审题自加需求：一开始脑补成“小于x在左、等于x在中间、大于x在右”，自己给自己加戏，差点写成三条链表分组。实际题目只要求两部分，等于x直接归到右边即可。
  2. 野指针崩溃：最早的错误写法是给节点val赋值，还写了head1=Lis1->next，但Lis1->next 从来没赋值过，全是内存垃圾值，一运行直接崩溃。正确做法是直接接入原节点：cur->next= 当前节点，然后cur后移。
  3. 链表成环坑：一开始漏掉了大链表尾部置NULL。原节点都带着旧的next指针，如果最后一个大节点原本指向某个小节点，拼接完成后链表会成环，判题直接超时、内存超限。
  4. 初始化隐患：malloc出来的哨兵节点，next是随机垃圾值，虽然代码后续会覆盖写入、侥幸能跑通，但本质属于未定义行为。严谨起见一定要手动初始化为NULL。
  5. 命名混乱坑：最开始变量名起成head11、head22、Lis1、Lis2，写着写着自己就搞混了哪个是哨兵、哪个是游走指针。改成见名知意的命名后，逻辑瞬间清晰了很多。

其他可行思路

  1. 头插法分组：遍历到小于x的节点就头插到小链表头部，大于等于的头插到大连表头部。优点是不用维护尾指针，写完直接得到头节点；缺点是会颠倒分区内节点的相对顺序，题目不要求保序时可以使用。
  2. 三段式分割：分成小于、等于、大于三条独立链表，最后按“小→中→大”的顺序拼接。就是我最开始脑补的“x放中间”的效果，属于拓展变种，只有题目明确要求时才需要用到。

五、刷题感悟与方法论总结

1. 思路朴素不代表效率低

最开始觉得双虚拟头尾插法思路太直白，不够“巧妙”，结果提交后击败了100%的用户。原因很现实：头插法虽然省了两个哨兵，但拼接时要额外遍历一次找尾巴，实际常数更大；尾插法一遍遍历全部搞定，实测运行反而更快。算法不是越花哨越好，常数小、边界少、不容易写错的写法，就是面试和刷题中的好写法。

2. 链表题通用避坑口诀

  • 修改next前先存后继，防止断链
  • 头节点不确定就上虚拟头，少处理边界
  • 拆分重组链表后，尾节点一定要手动置NULL，防止成环
  • malloc出来的节点，成员不会自动为NULL，手动初始化更稳妥

3. 审题永远是第一步

别像我一样自己给题目加需求，“等于x放中间”完全是脑补出来的条件。先把题意抠准、边界看清，再动手写代码，不然写半天都是无用功。

六、仓库说明

ProjectName
├─ 题目1
│  ├─ source                # 源代码文件夹
│  │  ├─ func.h             # 头文件
│  │  ├─ test.c
│  │  └─ blog_demo.c
│  └─ exe                   # 编译好的可运行程序文件夹
│     └─ main.exe           # Windows可执行程序
├─ 题目2
│  ├─ source
│  │  ├─ func.h
│  │  ├─ test.c
│  │  └─ blog_demo.c
│  └─ exe
│     └─ main.exe
├─ 题目3
│  ├─ source
│  │  ├─ func.h
│  │  ├─ test.c
│  │  └─ blog_demo.c
│  └─ exe
│     └─ main.exe
└─ 题目4
   ├─ source
   │  ├─ func.h
   │  ├─ test.c
   │  └─ blog_demo.c
   └─ exe
      └─ main.exe

Gitee 仓库：数据结构/单链表专题二（刷题复盘篇）：四道经典题踩坑记录+多思路对比 · Luminous/Code_2026 - 码云 - 开源中国

仓库包含 4 道编程题目，每题独立文件夹，无多余垃圾文件。 每个题目下有两个子文件夹：

  • source：源码目录
    • func.h：头文件，存放函数声明、结构体、宏定义
    • test.c：程序功能测试文件
    • blog_demo.c：博客文章配套演示源码
  • exe：编译输出目录
    • main.exe：Windows 已编译可执行文件，双击直接运行

使用方法

  • 看博客示例代码：题目x/source/blog_demo.c
  • 功能测试：编译运行 test.c
  • 直接运行程序：exe 目录双击main.exe
  • 重编译：GCC / Dev‑C++ / VS 编译源码生成新 exe

写在最后

这四道题刷下来，最大的感受是：链表题的核心永远是指针指向的管理，套路其实就那几种，多踩几次坑、多画几遍指针图，慢慢就会建立起直觉。下一篇继续刷快慢指针的进阶题型——环形链表、相交链表、倒数第k个节点，把龟兔赛跑算法彻底吃透。

 

标签
#算法 #数据结构 #链表 #笔记
链表算法精讲：高频题型与面试实战技巧
weixin_34197488的博客
08-11 336
链表作为基础数据结构，通过节点指针实现动态存储，在算法面试中占据重要地位。其核心原理在于指针操作与节点关系维护，技术价值体现在空间灵活性和高效插入删除特性上。典型应用场景包括LRU缓存、多项式运算等系统设计。针对链表操作中的指针丢失、边界处理等痛点，虚拟头节点和快慢指针成为工程实践中的关键技术，例如快慢指针算法能以O(n)时间复杂度检测环形链表。本文基于HOT100高频题库，提炼反转链表、合并有序链表等12种解题模板，涵盖字节跳动、腾讯等大厂面试真题，特别分享指针保存和dummy节点等防错技巧。
重邮802数据结构考研：从考纲到代码的精准复习与实战指南
weixin_34335458的博客
08-14 313
数据结构是计算机科学的核心基础，它研究数据的组织、存储和操作方式，其原理直接决定了算法的效率与程序的性能。理解线性表、树、图等逻辑结构及其物理实现，是掌握高效编程与系统设计的基石。在工程实践中，扎实的数据结构知识对于优化软件性能、解决大规模数据处理问题具有不可替代的价值，尤其在搜索引擎、数据库系统和操作系统等底层开发中应用广泛。对于备考重庆邮电大学802专业课的考生而言，精准对标考纲与历年真题是复习成败的关键。本文聚焦**考纲匹配度**与**真题导向性**，提供一套从资料甄别、知识体系构建到算法代码实战的完
单链表专题（一）-应用篇：三道经典题吃透删除、反转与快慢指针
Luminousone的博客
07-13 391
本文系统讲解单链表三大经典问题：移除元素、反转链表和查找中点。针对移除元素提出尾插法和虚拟头节点两种解法；反转链表详细解析三指针迭代和递归两种实现；查找中点重点分析快慢指针算法。文章强调单链表操作的核心在于指针修改和边界处理，总结出通用解题框架：处理头节点变化需采用新链表或虚拟头节点、修改指针前必须保存后继节点、必须验证空链表等边界场景。通过这三道基础题的深度剖析，帮助读者掌握单链表的核心操作与解题思路，为后续进阶题目打下坚实基础。
2019年Android与Java面试核心考点解析
weixin_30642869的博客
07-17 376
在移动开发领域，Android系统机制与Java虚拟机原理是开发者必须掌握的核心技术栈。从技术原理层面看，JVM内存模型决定了应用性能边界，而Android的Binder通信机制则是系统级交互的基础。这些底层知识直接关联到内存泄漏预防、线程池优化等工程实践，特别是在Handler机制、并发编程等高频考点中体现明显。2019年技术转型期，Jetpack组件和HTTP/2协议等新技术的应用场景成为面试重点，开发者需要同步掌握数据结构在RecyclerView缓存等实际场景的优化策略。通过构建包含核心机制、网络优
LeetCode高效刷题指南：从算法基础到面试实战的完整路径
weixin_30564785的博客
08-05 292
算法与数据结构是计算机科学的核心基础，其原理在于通过特定的数据组织和计算逻辑，高效地解决复杂问题。掌握它们的技术价值在于能显著提升开发者的计算思维和问题拆解能力，这是应对大型系统设计、性能优化及通过技术面试的关键。在实际应用场景中，无论是构建高并发服务、实现推荐系统，还是进行大数据处理，扎实的算法功底都不可或缺。本文聚焦于**动态规划**和**深度优先搜索**这两大核心武器，系统阐述如何通过专题化学习和科学的“三刷”练习法，将零散的题目内化为稳固的知识体系，从而在LeetCode训练和真实面试中游刃有余。
C 语言集中实践全记录：顺序表 + 单链表原理实现与通讯录项目实战【附可运行源码】
Luminousone的博客
07-14 236
本仓库为C语言数据结构线性存储结构的专项学习项目，完整记录了从基础概念到实际应用的开发流程。主要内容包括：1）动态顺序表的全套接口实现与通讯录管理系统开发，涵盖初始化、增删改查、扩容销毁等核心功能；2）单链表的基础操作实现与对比分析；3）真实项目开发中的问题调试经验，如输入缓冲区处理、字符串匹配优化等。项目提供完整源码、可执行文件及详细学习记录，特别适合C语言初学者系统学习数据结构。通过本项目可掌握线性表的两种存储方式差异，提升工程化编程能力。
蓝桥杯国赛冲刺：从算法基础到每日一练的系统化路径
congsikuai0611的博客
08-21 401
算法是计算机科学的核心，它通过一系列明确的指令解决特定问题，其效率由时间与空间复杂度衡量。理解算法原理，如分治、动态规划、贪心等思想，是构建高效程序的基础。掌握数据结构，如数组、链表、哈希表，是算法实现的物理载体。在工程实践中，算法能力直接决定了软件的性能上限与问题解决能力，尤其在数据处理、人工智能、搜索引擎等场景中至关重要。对于参加蓝桥杯等算法竞赛的开发者而言，系统化的知识体系与持续的刻意练习是提升竞争力的关键。本文聚焦于如何通过高效的“每日一练”方法，将算法基础与核心思想应用于竞赛准备，其中涉及对动态规
NOIP普及组初赛深度解析：从计算机基础到算法思维的实战复盘
weixin_34198881的博客
08-21 327
计算机科学的学习，尤其是算法与数据结构，是编程能力提升的核心基石。理解二进制、栈、队列等基础数据结构的工作原理，是分析程序行为和设计高效算法的前提。掌握时间复杂度分析、递归与递推等核心思想，能帮助开发者评估算法效率，优化代码性能。这些基础概念在信息学竞赛、软件工程面试和实际系统开发中都有广泛应用。本文以经典的NOIP普及组初赛试题为切入点，深入剖析了**进制转换**、**栈与队列**的操作特性以及**时间复杂度分析**中的常见误区，通过具体错题复盘，揭示了扎实的计算机基础与严谨的逻辑思维在解决实际问题中的关
复盘上次Redis缓存雪崩事故
m0_57700563的博客
06-26 117
前言 都知道MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 所以作为一名开发人员，掌握好MyBatis的使用是非常有必要的，特别是像阿里、腾讯等大厂都使用广泛，那么如何能够达到“精通”MyBatis的程度？今
Neso Academy数据结构教程：可视化动画与系统学习指南
weixin_33850015的博客
08-21 455
数据结构是计算机科学的核心基础，它研究数据的组织、存储与操作方式，直接影响程序的效率与性能。其原理在于通过数组、链表、栈、队列、树、图等抽象模型，在内存中高效地管理数据。掌握数据结构的技术价值在于能够设计出性能更优的软件系统，是解决复杂算法问题、进行系统性能优化的基石。其应用场景广泛，从数据库索引、编译器设计到网络路由、人工智能等领域都不可或缺。Neso Academy的【中英数据结构】系列教程，正是通过精炼的讲解和**可视化动画**，将链表指针移动、树结构旋转等抽象过程具象化，极大地降低了学习门槛。该系列
重邮802数据结构考研：手撕代码从零到实战，附C语言核心算法实现
weixin_30216561的博客
08-14 355
数据结构是计算机科学的核心基础，它研究数据的组织、存储和操作方式，其核心原理在于通过特定的逻辑结构（如线性表、树、图）和物理结构来高效管理数据。掌握数据结构与算法，对于提升程序性能、解决复杂工程问题具有至关重要的技术价值，广泛应用于搜索引擎、数据库系统、编译器设计等场景。本文聚焦考研实战，深入剖析线性表、栈、队列、树、图等关键数据结构的典型算法实现，并提供完整的C语言代码模板与常见错误分析，旨在帮助考生系统性地提升“手撕代码”能力，从容应对重邮802数据结构考研中的代码题挑战。
二叉树最近公共祖先算法详解：从递归到迭代的面试实战解析
最新发布
weixin_34075268的博客
08-22 729
二叉树是数据结构与算法中的核心基础，其遍历与搜索算法是解决众多计算问题的关键。深度优先搜索（DFS）和广度优先搜索（BFS）作为经典的图遍历思想，通过递归或迭代方式系统地访问节点，为路径查找、祖先关系判定等问题提供了通用框架。在工程实践中，高效地定位树中节点的特定关系，例如计算两个节点的最近公共祖先（LCA），对于优化数据库索引结构、加速编译器符号解析、乃至提升社交网络关系查询效率都具有重要价值。本文聚焦于这一高频面试考点，深入剖析利用递归分治与父指针映射两种主流方案求解LCA问题的核心原理与代码实现，并结
重庆邮电大学802数据结构考研：严蔚敏教材核心考点与高效复习指南
weixin_33805992的博客
08-14 496
数据结构是计算机科学的核心基础，它研究数据的组织、存储与操作方式，其原理在于通过逻辑与物理结构的有效映射，提升程序运行效率。掌握数据结构的技术价值在于能够设计出性能更优、资源消耗更少的算法与系统。在考研、求职笔试和软件开发等应用场景中，对数据结构与算法的深入理解是衡量工程师能力的关键标尺。本文聚焦于重庆邮电大学计算机考研专业课802数据结构，以严蔚敏版教材为蓝本，提供一份高效的备考路线图。内容涵盖**线性表、树与二叉树、图**等核心章节的重点剖析，以及**算法实现**专项训练，旨在帮助考生精准把握高频考点，
[学习方法论]掌握数据结构的长效记忆法
qq_55948352的博客
07-04 88
将数据结构视为解决问题的。
C++面试实战指南：从底层原理到系统设计，助你从容应对技术挑战
weixin_30740295的博客
07-10 385
在软件工程领域，内存管理和并发编程是构建高性能、高可靠系统的核心技术基础。理解内存分配机制（如new与malloc的区别）和多态的实现原理，不仅是掌握C++语言的关键，更是进行系统级优化的前提。这些底层知识直接影响程序的性能、稳定性和资源利用率，其技术价值在于能够帮助开发者设计出更高效、更安全的数据结构和算法。在实际应用场景中，无论是开发高性能服务器、游戏引擎，还是嵌入式系统，对内存模型和并发模型的深刻理解都至关重要。本文聚焦于C++面试中的高频考点，如智能指针的循环引用问题、线程安全的单例模式实现，以及如
数据结构与算法机考真题深度解析：从链表、二叉树到Dijkstra的实战指南
weixin_30855761的博客
08-06 538
数据结构与算法是计算机科学的核心基础，其原理在于通过特定的数据组织方式（如链表、树、图）和高效的算法策略（如动态规划、回溯），来优化程序的存储与计算效率。掌握这些技术对于解决复杂问题、提升软件性能具有关键价值，广泛应用于搜索引擎、推荐系统、路径规划等场景。本文聚焦于程序设计课程的机考真题，通过深度解析链表多项式加法、二叉树路径查找及Dijkstra最短路径等典型例题，结合【动态规划】和【递归】等核心热词，拆解从问题分析、算法选择到代码实现与调试的全过程，旨在为学习者提供一套从理论到实战的解题方法论与备考策略
嵌入式C/C++工程师进阶：VxWorks实时系统与算法面试实战解析
aofan9566的博客
07-28 434
实时操作系统（RTOS）是嵌入式领域的核心基础，其任务调度、中断处理和通信机制决定了系统的实时性与可靠性。VxWorks作为经典的RTOS，其微内核架构和确定性响应为工业控制、航空航天等关键领域提供了坚实保障。掌握其开发环境与内核原理，是深入理解嵌入式系统底层运行机制的关键。与此同时，数据结构与算法能力已成为中高级C/C++工程师的必备素养，尤其在应对互联网大厂技术面试时，对链表、树、哈希表等结构的熟练运用，以及动态规划、回溯等算法的深刻理解，是评估解决复杂问题潜力的重要标尺。本文聚焦**VxWorks任务
新疆大学828数据结构考研：算法设计能力提升与高频考点精析
weixin_30263073的博客
08-21 421
数据结构是计算机科学的核心基础，它研究数据的组织、存储和操作方式，直接影响程序的效率和性能。其核心原理在于通过逻辑结构（如线性表、树、图）和物理存储结构的有效结合，实现数据的高效管理。掌握数据结构对于提升算法设计能力、优化软件性能具有关键价值，广泛应用于数据库索引、编译器设计、网络路由等场景。在考研专业课复习中，精准把握目标院校的高频考点和命题风格至关重要。本文聚焦新疆大学计算机技术专业（085404）的初试科目“828数据结构”，深入解析其以“算法设计题”为核心的考核重点，并围绕“链表”和“二叉树遍历”等
小红书 算法一面 十一
XLYcmy的博客
08-20 440
例如 **Soft MoE** 采用这种方式，大幅提升负载均衡性，但会增加计算开销。- **熵正则化**：直接最大化门控概率分布的熵，熵越大表示分布越均匀，公式为 $\mathcal{L}_{ent} = -\frac{1}{N}\sum_{i=1}^N\sum_{k=1}^K p_{ik}\log p_{ik}$。- **核心原理**：源自 **GShard** 和 **Switch Transformer**，通过最小化专家选择概率分布的熵，迫使门控网络给每个专家分配相近的 token 数量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值