数据结构 王争 7 |链表(下):如何轻松写出正确的链表代码?

【数据结构系列】链表 在计算机科学中,链表是数据元素的线性集合,其每个元素都指向下一个元素,元素存储上并不连续可以分类为.单向链表,每个元素只知道其下一个元素是谁双向链表,每个元素知道其上一个元素和下一个元素循环链表,通常的链表尾节点tail指向的都是null,而循环链表的tail指向的是头节点head根据单向链表的定义,首先定义一个存储 value 和 next 指针的类 Node,和一个描述头部节点的引用// 头部节点private static class Node { // 节点类int value; 阅读详情

链表(下):如何轻松写出正确的链表代码?

上一节我讲了链表相关的基础知识。学完之后,我看到有人留言说,基础知识我都掌握了,但是写链表代码还是很费劲。哈哈,的确是这样的!

想要写好链表代码并不是容易的事儿,尤其是那些复杂的链表操作,比如链表反转、有序链表合并等,写的时候非常容易出错。从我上百场面试的经验来看,能把“链表反转”这几行代码写对的人不足 10%。

为什么链表代码这么难写?究竟怎样才能比较轻松地写出正确的链表代码呢?

只要愿意投入时间,我觉得大多数人都是可以学会的。比如说,如果你真的能花上一个周末或者一整天的时间,就去写链表反转这一个代码,多写几遍,一直练到能毫不费力地写出 Bug free 的代码。这个坎还会很难跨吗?

当然,自己有决心并且付出精力是成功的先决条件,除此之外,我们还需要一些方法和技巧。我根据自己的学习经历和工作经验,总结了几个写链表代码技巧。如果你能熟练掌握这几个技巧,加上你的主动和坚持,轻松拿下链表代码完全没有问题。

技巧一:理解指针或引用的含义

事实上,看懂链表的结构并不是很难,但是一旦把它和指针混在一起,就很容易让人摸不着头脑。所以,要想写对链表代码,首先就要理解好指针。

我们知道,有些语言有“指针”的概念,比如 C 语言;有些语言没有指针,取而代之的是“引用”,比如 Java、Python。不管是“指针”还是“引用”,实际上,它们的意思都是一样的,都是存储所指对象的内存地址。

接下来,我会拿 C 语言中的“指针”来讲解,如果你用的是 Java 或者其他没有指针的语言也没关系,你把它理解成“引用”就可以了。

实际上,对于指针的理解,你只需要记住下面这句话就可以了:

将某个变量赋值给指针,实际上就是将这个变量的地址赋值给指针,或者反过来说,指针中存储了这个变量的内存地址,指向了这个变量,通过指针就能找到这个变量。

这句话听起来还挺拗口的,你可以先记住。我们回到链表代码的编写过程中,我来慢慢给你解释。

在编写链表代码的时候,我们经常会有这样的代码:p->next=q。这行代码是说,p 结点中的 next 指针存储了 q 结点的内存地址。

还有一个更复杂的,也是我们写链表代码经常会用到的:p->next=p->next->next。这行代码表示,p 结点的 next 指针存储了 p 结点的下下一个结点的内存地址。

掌握了指针或引用的概念,你应该可以很轻松地看懂链表代码。恭喜你,已经离写出链表代码近了一步!

技巧二:警惕指针丢失和内存泄漏

不知道你有没有这样的感觉,写链表代码的时候,指针指来指去,一会儿就不知道指到哪里了。所以,我们在写的时候,一定注意不要弄丢了指针。

指针往往都是怎么弄丢的呢?我拿单链表的插入操作为例来给你分析一下。
插入结点

如图所示,我们希望在结点 a 和相邻的结点 b 之间插入结点 x,假设当前指针 p 指向结点 a。如果我们将代码实现变成下面这个样子,就会发生指针丢失和内存泄露。

p->next = x; //将p的next指针指向x结点
x->next = p->next; //将x的结点的next指针指向b结点

初学者经常会在这儿犯错。p->next 指针在完成第一步操作之后,已经不再指向结点 b 了,而是指向结点 x。第 2 行代码相当于将 x 赋值给 x->next,自己指向自己。因此,整个链表也就断成了两半,从结点 b 往后的所有结点都无法访问到了。

对于有些语言来说,比如 C 语言,内存管理是由程序员负责的,如果没有手动释放结点对应的内存空间,就会产生内存泄露。所以,我们插入结点时,一定要注意操作的顺序,要先将结点 x 的 next 指针指向结点 b,再把结点 a 的 next 指针指向结点 x,这样才不会丢失指针,导致内存泄漏。所以,对于刚刚的插入代码,我们只需要把第 1 行和第 2 行代码的顺序颠倒一下就可以了。

同理,删除链表结点时,也一定要记得手动释放内存空间,否则,也会出现内存泄漏的问题。当然,对于像 Java 这种虚拟机自动管理内存的编程语言来说,就不需要考虑这么多了。

技巧三:利用哨兵简化实现难度

首先,我们先来回顾一下单链表的插入和删除操作。如果我们在结点 p 后面插入一个新的结点,只需要下面两行代码就可以搞定。

new_node->next = p->next;
p->next = new_node;

但是,当我们要向一个空链表中插入第一个结点,刚刚的逻辑就不能用了。我们需要进行下面这样的特殊处理,其中 head 表示链表的头结点。所以,从这段代码,我们可以发现,对于单链表的插入操作,第一个结点和其他结点的插入逻辑是不一样的。

if( head == NULL){
  head = new_node;
}

我们再来看单链表结点删除操作。如果要删除结点P的后继结点,前面的删除代码就不行了。跟插入类似,我们也需要对这样情况特殊处理。写成代码是这样的:

if (head->next == NULL){
      head = null;
}

从前面的一步一步分析,我们可以看出,针对链表的插入、删除操作,需要对插入第一个结点和删除最后一个结点的情况进行特殊处理。这样代码实现起来就会很繁琐,不简洁,而且也容易因为考虑不全而出错。如何来解决这个问题呢?

技巧三中提到的哨兵就要登场了。哨兵,解决的是国家之间的边界问题。同理,这里说的哨兵也是解决“边界问题”的,不直接参与业务逻辑。

还记得如何表示一个空链表吗?head=null 表示链表中没有结点了。其中 head 表示头结点指针,指向链表中的第一个结点。

如果我们引入哨兵结点,在任何时候,不管链表是不是空,head 指针都会一直指向这个哨兵结点。我们也把这种有哨兵结点的链表叫带头链表。相反,没有哨兵结点的链表就叫作不带头链表。

我画了一个带头链表,你可以发现,哨兵结点是不存储数据的。因为哨兵结点一直存在,所以插入第一个结点和插入其他结点,删除最后一个结点和删除其他结点,都可以统一为相同的代码实现逻辑了。

带头链表

实际上,这种利用哨兵简化编程难度的技巧,在很多代码实现中都有用到,比如插入排序、归并排序、动态规划等。这些内容我们后面才会讲,现在为了让你感受更深,我再举一个非常简单的例子。代码我是用 C 语言实现的,不涉及语言方面的高级语法,很容易看懂,你可以类比到你熟悉的语言。

代码一:

// 在数组 a 中,查找 key,返回 key 所在的位置
// 其中,n 表示数组 a 的长度
int find(char* a, int n, char key) {
  // 边界条件处理,如果 a 为空,或者 n<=0,说明数组中没有数据,就不用 while 循环比较了
  if(a == null || n <= 0) {
    return -1;
  }
  
  int i = 0;
  // 这里有两个比较操作:i<n 和 a[i]==key.
  while (i < n) {
    if (a[i] == key) {
      return i;
    }
    ++i;
  }
  
  return -1;
}

代码二:

// 在数组 a 中,查找 key,返回 key 所在的位置
// 其中,n 表示数组 a 的长度
// 我举 2 个例子,你可以拿例子走一下代码
// a = {4, 2, 3, 5, 9, 6}  n=6 key = 7
// a = {4, 2, 3, 5, 9, 6}  n=6 key = 6
inf find(char* a, int n, char key) {
  if(a == null || n <= 0) {
    return -1;
  }
  
  // 这里因为要将 a[n-1] 的值替换成 key,所以要特殊处理这个值
  if (a[n-1] == key) {
    return n-1;
  }
  
  // 把 a[n-1] 的值临时保存在变量 tmp 中,以便之后恢复。tmp=6。
  // 之所以这样做的目的是:希望 find() 代码不要改变 a 数组中的内容
  char tmp = a[n-1];
  // 把 key 的值放到 a[n-1] 中,此时 a = {4, 2, 3, 5, 9, 7}
  a[n-1] = key;
  
  int i = 0;
  // while 循环比起代码一,少了 i<n 这个比较操作
  while (a[i] != key) {
    ++i;
  }
  
  // 恢复 a[n-1] 原来的值, 此时 a= {4, 2, 3, 5, 9, 6}
  a[n-1] = tmp;
  
  if (i == n-1) {
    // 如果 i == n-1 说明,在 0...n-2 之间都没有 key,所以返回 -1
    return -1;
  } else {
    // 否则,返回 i,就是等于 key 值的元素的下标
    return i;
  }
}

对比两段代码,在字符串 a 很长的时候,比如几万、几十万,你觉得哪段代码运行得更快点呢?答案是代码二,因为两段代码中执行次数最多就是 while 循环那一部分。第二段代码中,我们通过一个哨兵 a[n-1] = key,成功省掉了一个比较语句 i<n,不要小看这一条语句,当累积执行万次、几十万次时,累积的时间就很明显了。

当然,这只是为了举例说明哨兵的作用,你写代码的时候千万不要写第二段那样的代码,因为可读性太差了。大部分情况下,我们并不需要如此追求极致的性能。

##技巧四:重点留意边界条件处理
软件开发中,代码在一些边界或者异常情况下,最容易产生 Bug。链表代码也不例外。要实现没有 Bug 的链表代码,一定要在编写的过程中以及编写完成之后,检查边界条件是否考虑全面,以及代码在边界条件下是否能正确运行。

我经常用来检查链表代码是否正确的边界条件有这样几个:

如果链表为空时,代码是否能正常工作?

如果链表只包含一个结点时,代码是否能正常工作?

如果链表只包含两个结点时,代码是否能正常工作?

代码逻辑在处理头结点和尾结点的时候,是否能正常工作?

当你写完链表代码之后,除了看下你写的代码在正常的情况下能否工作,还要看下在上面我列举的几个边界条件下,代码仍然能否正确工作。如果这些边界条件下都没有问题,那基本上可以认为没有问题了。

当然,边界条件不止我列举的那些。针对不同的场景,可能还有特定的边界条件,这个需要你自己去思考,不过套路都是一样的。

实际上,不光光是写链表代码,你在写任何代码时,也千万不要只是实现业务正常情况下的功能就好了,一定要多想想,你的代码在运行的时候,可能会遇到哪些边界情况或者异常情况。遇到了应该如何应对,这样写出来的代码才够健壮!

技巧五:举例画图,辅助思考

对于稍微复杂的链表操作,比如前面我们提到的单链表反转,指针一会儿指这,一会儿指那,一会儿就被绕晕了。总感觉脑容量不够,想不清楚。所以这个时候就要使用大招了,举例法和画图法。

你可以找一个具体的例子,把它画在纸上,释放一些脑容量,留更多的给逻辑思考,这样就会感觉到思路清晰很多。比如往单链表中插入一个数据这样一个操作,我一般都是把各种情况都举一个例子,画出插入前和插入后的链表变化,如图所示:

操作

看图写代码,是不是就简单多啦?而且,当我们写完代码之后,也可以举几个例子,画在纸上,照着代码走一遍,很容易就能发现代码中的 Bug。

##技巧六:多写多练,没有捷径
如果你已经理解并掌握了我前面所讲的方法,但是手写链表代码还是会出现各种各样的错误,也不要着急。因为我最开始学的时候,这种状况也持续了一段时间。

现在我写这些代码,简直就和“玩儿”一样,其实也没有什么技巧,就是把常见的链表操作都自己多写几遍,出问题就一点一点调试,熟能生巧!

所以,我精选了 5 个常见的链表操作。你只要把这几个操作都能写熟练,不熟就多写几遍,我保证你之后再也不会害怕写链表代码。

单链表反转

链表中环的检测

两个有序的链表合并

删除链表倒数第 n 个结点

求链表的中间结点

内容小结

这节我主要和你讲了写出正确链表代码的六个技巧。分别是理解指针或引用的含义、警惕指针丢失和内存泄漏、利用哨兵简化实现难度、重点留意边界条件处理,以及举例画图、辅助思考,还有多写多练。

我觉得,写链表代码是最考验逻辑思维能力的。因为,链表代码到处都是指针的操作、边界条件的处理,稍有不慎就容易产生 Bug。链表代码写得好坏,可以看出一个人写代码是否够细心,考虑问题是否全面,思维是否缜密。所以,这也是很多面试官喜欢让人手写链表代码的原因。所以,这一节讲到的东西,你一定要自己写代码实现一下,才有效果。

课后思考

今天我们讲到用哨兵来简化编码实现,你是否还能够想到其他场景,利用哨兵可以大大地简化编码难度?

精彩评论

总结:如何优雅的写出链表代码?6大学习技巧

一、理解指针或引用的含义
1.含义:将某个变量(对象)赋值给指针(引用),实际上就是就是将这个变量(对象)的地址赋值给指针(引用)。
2.示例:
p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。
p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。

二、警惕指针丢失和内存泄漏(单链表)
1.插入节点
在节点a和节点b之间插入节点x,b是a的下一节点,,p指针指向节点a,则造成指针丢失和内存泄漏的代码:p—>next = x;x—>next = p—>next; 显然这会导致x节点的后继指针指向自身。
正确的写法是2句代码交换顺序,即:x—>next = p—>next; p—>next = x;
2.删除节点
在节点a和节点b之间删除节点b,b是a的下一节点,p指针指向节点a:p—>next = p—>next—>next;

三、利用“哨兵”简化实现难度
1.什么是“哨兵”?
链表中的“哨兵”节点是解决边界问题的,不参与业务逻辑。如果我们引入“哨兵”节点,则不管链表是否为空,head指针都会指向这个“哨兵”节点。我们把这种有“哨兵”节点的链表称为带头链表,相反,没有“哨兵”节点的链表就称为不带头链表。
2.未引入“哨兵”的情况
如果在p节点后插入一个节点,只需2行代码即可搞定:
new_node—>next = p—>next;
p—>next = new_node;
但,若向空链表中插入一个节点,则代码如下:
if(head == null){
head = new_node;
}
如果要删除节点p的后继节点,只需1行代码即可搞定:
p—>next = p—>next—>next;
但,若是删除链表的最有一个节点(链表中只剩下这个节点),则代码如下:
if(head—>next == null){
head = null;
}
从上面的情况可以看出,针对链表的插入、删除操作,需要对插入第一个节点和删除最后一个节点的情况进行特殊处理。这样代码就会显得很繁琐,所以引入“哨兵”节点来解决这个问题。
3.引入“哨兵”的情况
“哨兵”节点不存储数据,无论链表是否为空,head指针都会指向它,作为链表的头结点始终存在。这样,插入第一个节点和插入其他节点,删除最后一个节点和删除其他节点都可以统一为相同的代码实现逻辑了。
4.“哨兵”还有哪些应用场景?
这个知识有限,暂时想不出来呀!但总结起来,哨兵最大的作用就是简化边界条件的处理。

四、重点留意边界条件处理
经常用来检查链表是否正确的边界4个边界条件:
1.如果链表为空时,代码是否能正常工作?
2.如果链表只包含一个节点时,代码是否能正常工作?
3.如果链表只包含两个节点时,代码是否能正常工作?
4.代码逻辑在处理头尾节点时是否能正常工作?

五、举例画图,辅助思考
核心思想:释放脑容量,留更多的给逻辑思考,这样就会感觉到思路清晰很多。

六、多写多练,没有捷径
5个常见的链表操作:
1.单链表反转
2.链表中环的检测
3.两个有序链表合并
4.删除链表倒数第n个节点
5.求链表的中间节点

练习题LeetCode对应编号:206,141,21,19,876。大家可以去练习,另外建议作者兄每章直接给出LC的题目编号或链接方便大家练习。

S4 Hana SD -信贷管理 - 02 在S4版本中,客户的信用管理数据在事务代码BP维护,业务伙伴角色是UKM000。在维护过程中,我们并不能直接输入信贷控制范围这个组织架构,而是需要输入一个信用段,并且在信用段的维度下去维护相应信用管理数据。对于信用段,可以分为主信用段(信用段是0000)和其他临时信用段,我们可以通过配置把次级信用段的客户信贷负债汇总到主信用段。当然,在后台也有配置,会把信用段和信贷控制范围这两者进行关联.3.2SPROIMG > 财务供应链管理 > 信用管理 > 信贷风险监视 > 主数据 > 创建信用段。 阅读详情

相关推荐

[WeChatMsg]导出csv格式微信聊天记录的手把手教程

手把手教大家如何导出自己的聊天记录得到csv文件,即使是电脑小白也可以轻松学会o(* ̄▽ ̄*)ブ

weixin_51094633的博客 1万+

【数据结构与算法-基础篇】

数据结构与算法 前言 本文只是学习极客时间 王争老师的《数据结构与算法》付费课程的学习笔记与心得,对《数据结构与算法》这门课有兴趣的同志可以通过以下链接购买专栏: https://time.geekbang.org/column/intro/100017301 附一张数据结构合算法知识地图: 一.复杂度分析 1.什么是复杂度分析? 1.复杂度描述的是算法执行时间(或占用空间)与数据规模的增长关系 2.时间复杂度:   大 O 时间复杂度实际上并不具体表示代码真正的执行时间,而是表示代码执行时间随数据规模增

qq_41201565的博客 981

生信分析实战指南:Linux环境下EMBOSS的安装与核心功能详解

本文详细介绍了在Linux环境下安装和使用EMBOSS工具包的实战指南,涵盖源码编译、包管理器安装和Conda安装三种方法,并演示了序列比对、序列特征提取和引物设计等核心功能。EMBOSS作为生物信息学领域的开源工具集,适用于序列分析、蛋白质结构预测等多种任务,帮助研究人员高效完成生信分析工作。

weixin_29202213的博客 466

王争《数据结构与算法之美》笔记_下篇

排序、查找、跳表、散列表、哈希算法、二叉树、图

qq_41697157的博客 722

HackRF实战:用Portapack扩展板玩转GPS信号模拟(附固件刷写教程)

本文详细介绍了如何使用HackRF与Portapack扩展板进行GPS信号模拟,包括固件刷写、信号生成与发射配置等实战操作。通过专业工具和优化技巧,读者可以掌握软件无线电的高级应用,解决手机定位难题,同时强调安全合规使用的重要性。

weixin_28717431的博客 366

Zabbix 简介、优缺点、基础原理

(8条消息) Zabbix 的基础概念、原理和架构_Lee木木的博客-优快云博客_zabbix架构类型Zabbix 的基础概念、原理和架构_Lee木木的博客-优快云博客_zabbix架构类型 --------------------------------------------------------------------------------------------------------------------------- 一、Zabbix 简介 Zabbix是由A...

weixin_50196615的博客 2037

王争数据结构与算法之美开篇问题整理

数据结构与算法之美笔记整理 为什么大多数编程语言中数组从 0 而不是从 1 开始编号? 从数组存储的内存模型上来看,“下标”最确切的定义应该是“偏移(offset)”。如果用 a 来表示数组的首地址,a[0]就是偏移为 0 的位置,也就是首地址,a[k]就表示偏移 k 个 type_size 的位置,所以计算 a[k]的内存地址只需要用这个公式: a[k]_address = base_address + k * type_size 如何基于链表实现 LRU 缓存淘汰算法? 维护一个有序单链表,越

ellie_chen的博客 818

S32K1XX调试--快速定位HardFault

1、背景 程序运行,发现程序跑飞到HardFault,但不清楚为什么会跑到HardFault中断处理函数去。 2、分析 要想知道为什么会跑到HardFault_Handler中去,就很有必要了解一下,程序上一条执行的是那条命令。 根据汇编指令可以定位上条指令,但如果对汇编指令不是很了解的话,那就很头疼了 根据单步运行也能实现定位,但如果程序量很大,又很杂,可能花费的时间就比较久些。 3、问题查找 提供一种不需要懂汇编指令的查找方法,方法如下: 在中断处理函数中插入以下代码,以及另外定义

ping_devil的博客 4020

入门篇001:为什么要学习数据结构与算法 by 王争(摘取对自己有用部分)

说明:内容摘自:《数据结构与算法之美》 by:王争 选取自己所需部分内容。 1.不想一辈子只会基本的CRUD; 2.作为业务开发,我们会用到各种框架、中间件和底层系统,比如 Spring、RPC 框架、消息中间件、Redis 等等。 在这些基础框架中,一般都揉和了很多基础数据结构和算法的设计思想。比如,我们常用的 Key-Value 数据库 Redis 中,里面的有序集合是用什么数据...

weixin_38653045的博客 314

PCL 直通滤波

内容抄自优快云点云侠:[【2024最新版】PCL点云处理算法汇总(C++长期更新版)](https://blog.youkuaiyun.com/qq_36686437/article/details/114160640)。质量无忧,永久免费,可放心复制粘贴。

m0_51204289的博客 906

S7-200SMART通过表格指令实现模拟量信号滑动平均值滤波的具体方法

S7-200SMART通过表格指令实现模拟量信号滑动平均值滤波的具体方法

Robot_PLC_HMI_Automation 6729

数据结构 王争 6 |链表(上):如何实现LRU缓存淘汰算法?

链表(上):如何实现LRU缓存淘汰算法? 今天我们来聊聊“链表(Linked list)”这个数据结构。学习链表有什么用呢?为了回答这个问题,我们先来讨论一个经典的链表应用场景,那就是 LRU 缓存淘汰算法。 缓存是一种提高数据读取性能的技术,在硬件设计、软件开发中都有着非常广泛的应用,比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。 缓存的大小有限,当缓存被用满时,哪些数据应该被清理出去,...

GhostintheCode的博客 675

Cleo Synchronization接口任意文件读取漏洞CVE-2024-50623 附POC

微信公众号搜索:南风漏洞复现文库该文章 南风漏洞复现文库 公众号首发Cleo。

nnn2188185的博客 482

链表:如何轻松写出正确的链表代码?

链表:如何轻松写出正确的链表代码? 链表代码技巧 一:理解指针或引用的含义 指针都是存储所指对象的内存地址 将某个变量赋值给指针,实际上就是将这个变量的地址赋值给指针,或者说就是指针中存储了这个变量的内存地址,指向了这个变量,通过指针就能找到这个变量 在编写代码的时候会有p->next = q,意思是p结点中的next指针存储了q结点的内存地址 再如p->next = p->ne...

ywangjiyl的博客 225

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【04】 链表下:如何轻松写出正确的链表代码?

【04】 链表下:如何轻松写出正确的链表代码?1. 理解指针或引用的含义2. 警惕指针丢失和内存泄漏(单链表)3. 利用“哨兵”简化实现难度4. 重点留意边界条件处理5. 举例画图,辅助思考6. 多写多练,没有捷径7. 一些经验8. LeetCode练习题9. 参考资料10. 声明 1. 理解指针或引用的含义 含义:将某个变量(对象)赋值给指针(引用),实际上就是就是将这个变量(对象)的地址赋值...

Jock2018的博客 234

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

7链表:如何轻松写出正确的链表代码

1、理解指针或引用的含义 1)含义:将某个变量(对象)赋值给指针(引用),实际上就是将这个变量(对象)的地址赋值给指针(引用)。 2)示例: p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。 p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。 2、警惕指针丢失和内存泄漏(单链表) 1)插入节点 在...

qq_35270493的博客 363

7、链表(下):如何轻松写出正确的链表代码?

很汗颜,现在让自己完整的写出一个简单的链表结构竟然会无法动笔,作为一个程序猿,需要修行的路还很长。 技巧一:理解指针或引用的含义 将某个变量赋值给指针,实际上就是将这个变量的地址赋值给指针,或者反过来说,指针中存储了这个变量的内存地址,指向了这个变量,通过指针就能找到这个变量。 例子: p->next = q。这行代码的意思是p节点的next指针存储了q节点的内存地址。 ...

171

链表(下):如何轻松写出正确的链表代码?

上一篇文章我们已经了解过了链表的相关基础知识,现在总结几个写链表代码的技巧,如能熟练掌握这些那么就可以轻松的写出链表的代码。。。。 技巧一、理解指针或引用的含义 事实上链表的结构并不是很难,但是一旦将它和“引用”混在一起的话就会很难了,想要写对链表代码首先就要理解好指针。。 下面会用Java语言举例子。。一段代码实例化的时候实例就可以理解为指针,指向创建的对象地址。。 技巧二、警惕指针丢失和内存泄...

weixin_44240370的博客 298

极客时间——数据结构与算法(7):如何轻松写出正确的链表代码?

链表的基础知识很简单,但是 想要写好链表代码并不是容易的事儿,尤其是那些复杂的链表操作,比如链表反转、有序链表合并等。下面推荐几个写链表代码的技巧: 技巧一:理解指针或引用的含义 事实上,看懂链表的结构并不是很难,但是一旦把它和指针混在一起,就很容易让人摸不着头脑。所以,要想写对链表代码,首先就要理解好指针。  我们知道,有些语言有“指针”的概念,比如 C 语言;有些语言没有指针,取而代之...

weixin_40805079的博客 254

轻松搞定面试中的链表题目

版权所有,转载请注明出处,谢谢! http://blog.youkuaiyun.com/walkinginthewind/article/details/7393134 链表是最基本的数据结构,面试官也常常用链表来考察面试者的基本能力,而且链表相关的操作相对而言比较简单,也适合考察写代码的能力。链表的操作也离不开指针,指针又很容易导致出错。综合多方面的原因,链表题目在面试中占据着很重要的地位。本文对链

计算机的艺术 6万+

【数据结构与算法】一套链表 OJ 带你轻松玩转链表

十道链表OJ轻松上手,拓宽你对链表的认知

bit me的博客 2157

数据结构(二):链表

文章目录一、链表的概念及其结构二、单链表的实现1.单链表的访问2.单链表头部插入数据3.单链表尾部插入数据4.单链表头部删除数据5.单链表尾部删除数据6.查找单链表中值为x的结点7.在某一结点的后面插入一个结点8.在某一结点的后面删除一个结点三、单链表的优劣四、 带头循环双向链表的实现1.双向链表的初始化2.双向链表尾部插入数据3.双向链表头部插入数据4.双向链表尾部删除数据5.双向链表头部删除数据6.寻找双向链表中值为x的结点7.在pos位置前插入一个结点8.删除pos结点9.得到链表的结点个数感谢阅读.

weixin_51983604的博客 3411

【数据结构副本篇】顺序表 链表OJ

学习其实和打游戏一样,当你觉得BOSS难打的时候就说明是你的等级和装备不够,此时就需要我们多去刷刷副本,增加一点经验,顺便爆点装备出来,提升自己,从而轻松搞定BOSS。

m0_74779094的博客 2566

【轻松学数据结构】硬核手撕数据结构中的顺序表、单(双)链表、环形链表、静态链表(六千字超详细教程,附源码)

🌱本专栏将使用Java语言实现所有数据结构(如有需要,也可以用C++实现)。本专栏将会从基础开始,循序渐进,也请大家多多支持。数据结构虽然难,但只要肯坚持,一定能学好,希望大家都能够从中获益。 📫专栏地址:数据结构专栏 📫本专栏的所有代码都将更新在Gitee上,项目地址:项目地址 📫相关数据结构演示软件:链接地址 📫在线演示地址:https://visualgo.net/zh https://algorithm-visualizer.org/ 文章目录线性表的介绍线性表的定义顺序表的基本操作顺序表的插.

Learning_xzj的博客 1677

数据结构:线性表之-循环双向链表(万字详解)

双向链表(Doubly Linked List)是一种常见的链表数据结构。它与普通链表的区别在于,每个节点都有两个指针,一个指向前一个节点,一个指向后一个节点,因此可以从任意一个节点开始,双向遍历整个链表。双向链表的节点通常由三部分组成:数据部分(存储节点的值)、前驱指针(指向前一个节点的指针)和后继指针(指向后一个节点的指针)。相比于单向链表,双向链表可以更方便地进行正反向遍历和节点的插入、删除操作。

2301_77649794的博客 5441

(十)数据结构之十字链表

文章目录1,内容概述2,什么是十字链表3,十字链表应用4,十字链表算法分析5,实现代码6,运行截图7,一点注意8,ending 1,内容概述  主要介绍数据结构图的存储结构之一:十字链表的实现。 2,什么是十字链表  十字链表是图的邻接表与逆邻接表相结合的一种存储结构。(传送门 :邻接表、邻接矩阵数据结构)  特点:源于邻接表、逆邻接表却胜于它们,十字链表将弧尾节点相同的弧串联在一条链表上,将弧首...

温柔的博客 4374

Java“链表“——数据结构(这一篇就够了)

本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解: 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景

m0_73158088的博客 4317
上一篇: 数据结构 王争 6 |链表(上):如何实现LRU缓存淘汰算法?
下一篇: 数据结构 王争 8 |栈:如何实现浏览器的前进和后退功能?
GhostintheCode
博客等级 码龄8年 53粉丝 105原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值