登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›代码随想录第三天 | 链表part01

代码随想录第三天 | 链表part01

滤冽 6 天前
链表理论基础
建议：了解一下链表基础，以及链表和数组的区别
文章链接：https://programmercarl.com/链表理论基础.html
不是很了解链表和数组区别的可以先看看以上的文章。
203.移除链表元素
建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。
题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.移除链表元素.html
题目感想：
1.第一种方法通过添加虚拟头节点来实现，方法很简单，新建一个虚拟头节点指向链表的原始头节点，然后开始递推即可，知道当前节点的下一个节点为NULL时退出递推，返回虚拟头节点.NEXT的节点即可，
为什么不返回原始头节点？因为原始头节点可能在处理的过程中被删了。
下面说一下递推逻辑，如果当前节点.NEXT的值为目标删除值，那我们则将当前节点的NEXT赋值为当前节点的NEXT的NEXT，相当于跳过这个节点了嘛，
如果当前节点.NEXT的值不是目标删除值，那么就移动索引到下一个节点，继续递推。
由于作者使用的编程语言是Java不用手动去管理内存，所以就能这么写，其他语言的同学就要注意一下是否需要管理内存了。
  1.     dummy.next = head;
  2.     ListNode cur = dummy;
  3.     while (cur.next != null) {
  4.         if (cur.next.val == val) {
  5.             cur.next = cur.next.next;
  6.         } else {
  7.             cur = cur.next;
  8.         }
  9.     }
  10.     return dummy.next;
复制代码
2.第二种方法是通过递归来实现，这里的递归可能不是很好理解，建议看看b站图码up的关于递归的视频:https://www.bilibili.com/video/BV1ks421w7cA/?spm_id_from=333.337.search-card.all.click&vd_source=25c680837f40da985c0f44b5389b5735
一句话来说就是，把一个大的问题依次判断直到得到一个我们能解决的小问题，然后往回递归就能把大问题给解决了，这里可能有的同学觉得会和分治很像，其实不是的，分治是平铺的，递归是有层次关系的，不过有时候分治的思想和递归的方法会同时应用在解决一个问题上，感兴趣的朋友可以在评论区交流一下。
回到这个题目，这个题目的递归出口就是当前节点的下个节点为NULL，然后往回递归的逻辑是这样的：判断当前节点的值是否是目标，是则返回这个节点的.NEXT节点，不是则返回这个节点，相当于从尾部开始删除嘛，代码如下：
  1. public ListNode removeElements(ListNode head, int val) {
  2.         if (head == null) {
  3.             return head;
  4.         }
  6.         head.next = removeElements(head.next, val);
  7.         if (head.val == val) {
  8.             return head.next;
  9.         }
  10.         return head;
  11.     }
复制代码
707.设计链表
建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点
题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.设计链表.html
题目感想：
1.还是有两种常用的方法，第一种是单链表，这里主要说一下核心的思路：我们需要定义好链表节点，然后就是采用虚拟头节点的方式，如果是添加操作我们需要看看是否索引有效，之后找到要添加位置的前置节点，接下来就是让新节点的NEXT指向前置节点的NEXT，前置节点的NEXT指向新节点，需要注意的是我们添加了虚拟头节点，所以遍历时要注意遍历到的节点是否是我们需要的前置节点，删除操作参考上一题，查找也是遍历，在首尾添加其实也是可以复用新增节点的那个方法，首添加注意虚拟头节点，尾添加直接遍历至NEXT为NULL即可找到；
2.第二种方法是双链表法，就是每个节点既有指向后一节点的指针也有指向前一节点的指针，这就使得我们可以从前后两个位置进行遍历，需要注意的是，初始化双链表的时候我们需要将首尾节点互相指向，然后就是为了充分利用双链表，我们在进行一些有关索引的操作时，可以先进行判断该索引是离首节点近还是尾节点近，然后就和之前单链表的遍历逻辑一致了，同样的，由于有两头，我们在进行遍历或者在首尾添加新节点时需要考虑虚拟头尾节点的影响；
  1. //单链表
  2. class MyLinkedList {
  4.     class ListNode {
  5.         int val;
  6.         ListNode next;
  7.         ListNode(int val) {
  8.             this.val=val;
  9.         }
  10.     }
  11.     //size存储链表元素的个数
  12.     private int size;
  13.     //注意这里记录的是虚拟头结点
  14.     private ListNode head;
  16.     //初始化链表
  17.     public MyLinkedList() {
  18.         this.size = 0;
  19.         this.head = new ListNode(0);
  20.     }
  22.     //获取第index个节点的数值，注意index是从0开始的，第0个节点就是虚拟头结点
  23.     public int get(int index) {
  24.         //如果index非法，返回-1
  25.         if (index < 0 || index >= size) {
  26.             return -1;
  27.         }
  28.         ListNode cur = head;
  29.         //第0个节点是虚拟头节点，所以查找第 index+1 个节点
  30.         for (int i = 0; i <= index; i++) {
  31.             cur = cur.next;
  32.         }
  33.         return cur.val;
  34.     }
  36.     public void addAtHead(int val) {
  37.         ListNode newNode = new ListNode(val);
  38.         newNode.next = head.next;
  39.         head.next = newNode;
  40.         size++;
  42.         // 在链表最前面插入一个节点，等价于在第0个元素前添加
  43.         // addAtIndex(0, val);
  44.     }
  46.     public void addAtTail(int val) {
  47.         ListNode newNode = new ListNode(val);
  48.         ListNode cur = head;
  49.         while (cur.next != null) {
  50.             cur = cur.next;
  51.         }
  52.         cur.next = newNode;
  53.         size++;
  55.         // 在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
  56.         // addAtIndex(size, val);
  57.     }
  59.     // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
  60.     // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
  61.     // 如果 index 大于链表的长度，则返回空
  62.     public void addAtIndex(int index, int val) {
  63.         if (index < 0 || index > size) {
  64.             return;
  65.         }
  67.         //找到要插入节点的前驱
  68.         ListNode pre = head;
  69.         for (int i = 0; i < index; i++) {
  70.             pre = pre.next;
  71.         }
  72.         ListNode newNode = new ListNode(val);
  73.         newNode.next = pre.next;
  74.         pre.next = newNode;
  75.         size++;
  76.     }
  78.     public void deleteAtIndex(int index) {
  79.         if (index < 0 || index >= size) {
  80.             return;
  81.         }
  82.         //因为有虚拟头节点，所以不用对index=0的情况进行特殊处理
  83.         ListNode pre = head;
  84.         for (int i = 0; i < index ; i++) {
  85.             pre = pre.next;
  86.         }
  87.         pre.next = pre.next.next;
  88.         size--;
  89.     }
  90. }
复制代码
  1. //双链表
  2. class MyLinkedList {
  4.     class ListNode{
  5.         int val;
  6.         ListNode next, prev;
  7.         ListNode(int val){
  8.             this.val = val;
  9.         }
  10.     }
  12.     //记录链表中元素的数量
  13.     private int size;
  14.     //记录链表的虚拟头结点和尾结点
  15.     private ListNode head, tail;
  16.     public MyLinkedList() {
  17.         //初始化操作
  18.         this.size = 0;
  19.         this.head = new ListNode(0);
  20.         this.tail = new ListNode(0);
  21.         //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
  22.         this.head.next = tail;
  23.         this.tail.prev = head;
  24.     }
  25.     public int get(int index) {
  26.         //判断index是否有效
  27.         if(index < 0 || index >= size){
  28.             return -1;
  29.         }
  30.         ListNode cur = head;
  31.         //判断是哪一边遍历时间更短
  32.         if(index >= size / 2){
  33.             //tail开始
  34.             cur = tail;
  35.             for(int i = 0; i < size - index; i++){
  36.                 cur = cur.prev;
  37.             }
  38.         }else{
  39.             for(int i = 0; i <= index; i++){
  40.                 cur = cur.next;
  41.             }
  42.         }
  43.         return cur.val;
  44.     }
  45.     public void addAtHead(int val) {
  46.         //等价于在第0个元素前添加
  47.         addAtIndex(0, val);
  48.     }
  49.     public void addAtTail(int val) {
  50.         //等价于在最后一个元素(null)前添加
  51.         addAtIndex(size, val);
  52.     }
  53.     public void addAtIndex(int index, int val) {
  54.         //判断index是否有效
  55.         if(index < 0 || index > size){
  56.             return;
  57.         }
  59.         //找到前驱
  60.         ListNode pre = head;
  61.         for(int i = 0; i < index; i++){
  62.             pre = pre.next;
  63.         }
  64.         //新建结点
  65.         ListNode newNode = new ListNode(val);
  66.         newNode.next = pre.next;
  67.         pre.next.prev = newNode;
  68.         newNode.prev = pre;
  69.         pre.next = newNode;
  70.         size++;
  71.     }
  72.     public void deleteAtIndex(int index) {
  73.         //判断index是否有效
  74.         if(index < 0 || index >= size){
  75.             return;
  76.         }
  78.         //删除操作
  79.         ListNode pre = head;
  80.         for(int i = 0; i < index; i++){
  81.             pre = pre.next;
  82.         }
  83.         pre.next.next.prev = pre;
  84.         pre.next = pre.next.next;
  85.         size--;
  86.     }
  87. }
复制代码
206.反转链表
建议先看我的视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。
题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.翻转链表.html
题目感想：
1.这个题目有三种方法，先说最简单的，只用三个指针就能迭代完成，主要的思路是，初始化一个节点cur赋值为头节点，初始化一个NULL节点，这个节点主要是用来存cur反转后指向的节点，再初始化一个临时节点用来存NEXT节点是哪个，便于继续遍历，下面进行举例，首先临时节点先保存cur的NEXT节点，然后cur节点的NEXT指向NULL节点，NULL节点再保存cur节点，cur节点转换为临时节点保存的那个节点，开始下一个循环；
  1. public ListNode reverseList(ListNode head) {
  2.         ListNode prev = null;
  3.         ListNode cur = head;
  4.         ListNode temp = null;
  5.         while (cur != null) {
  6.             temp = cur.next;// 保存下一个节点
  7.             cur.next = prev;
  8.             prev = cur;
  9.             cur = temp;
  10.         }
  11.         return prev;
  12.     }
复制代码
2.第二种方法就是递归，这里的递归有两种方式，第一种方式就是从前往后递归，还有一种是从后往前递归，先说从前递归，和上面的方法一一样，也需要三个节点进行工作，然后将反转之后的大块的继续进行递归；
  1. public ListNode reverseList(ListNode head) {
  2.         return reverse(null, head);
  3.     }
  5.     private ListNode reverse(ListNode prev, ListNode cur) {
  6.         if (cur == null) {
  7.             return prev;
  8.         }
  9.         ListNode temp = null;
  10.         temp = cur.next;// 先保存下一个节点
  11.         cur.next = prev;// 反转
  12.         // 更新prev、cur位置
  13.         // prev = cur;
  14.         // cur = temp;
  15.         return reverse(cur, temp);
  16.     }
复制代码
从后往前就是先一路递归到末尾，然后递归回来的时候再处理数据
  1.     ListNode reverseList(ListNode head) {
  2.         // 边缘条件判断
  3.         if(head == null) return null;
  4.         if (head.next == null) return head;
  6.         // 递归调用，翻转第二个节点开始往后的链表
  7.         ListNode last = reverseList(head.next);
  8.         // 翻转头节点与第二个节点的指向
  9.         head.next.next = head;
  10.         // 此时的 head 节点为尾节点，next 需要指向 NULL
  11.         head.next = null;
  12.         return last;
  13.     }
复制代码
需要注意的点：
1.递归的使用还是不是很熟练，明天整理一下递归的相关笔记；

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
滤冽
6 天前

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫