第二章链表part01 链表理论基础 203.移除链表元素 707.设计链表 206.反转链表-CSDN博客

本文链接：https://blog.csdn.net/qq_45498567/article/details/132242326

第三天| 第二章链表part01 链表理论基础 203.移除链表元素 707.设计链表 206.反转链表

链表理论基础

建议：了解一下链接基础，以及链表和数组的区别
文章链接：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

203.移除链表元素

题目链接：https://leetcode.cn/problems/remove-linked-list-elements/description/
文章讲解：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
解法：（因为涉及到是否删除头节点，所以有以下两种解法）
- 第一种：直接删除
  - 先判断head是否为空，空的话直接返回head即可。
  - 因为头节点的删除与其他中间节点不同，所以需要单独讨论。
    - 如果头节点不为空，并且头节点中的值是目标值的话，就将头节点向他的next位置移动，即head = head.next;
  - 其他中间节点，需要指定一个指针cur，cur指向头节点，通过cur指针的移动遍历整个链表，因为要判断中间节点的val是否与目标值相等，因此需要保证cur.next != null; 。如果cur.next.val是目标值，就将这个节点删除掉。
    - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sHwzSyay-1691778284104)(C:\Users\LENOVO\AppData\Roaming\Typora\typora-user-images\image-20230811235113322.png)]
  - 代码如下：
    - ```
    class Solution {
        public ListNode removeElements(ListNode head, int val) {
            ListNode cur = head;
            if (head == null) {
                return head;
            }
            while (head != null && head.val == val) {
                head = head.next;
            }
            while (cur.next != null) {
                if (cur.next.val == val) {
                    cur.next = cur.next.next;
                } else {
                    cur = cur.next;
                }
            }
            return head;
        }
    }
```
- 第二种：虚拟头节点：
  - 思路：给现有的链表加一个虚拟的头节点，那么原来的链表头节点就成为一个中间节点，可以统一处理了。如果cur.next.val与目标值相等，那么和解法一一样，将cur.next赋值为cur.next.next，否则就让指针向后移一位。
  - 代码：
    - ```
    class Solution {
        public ListNode removeElements(ListNode head, int val) {
            ListNode dummyHead = new ListNode(-1, head);
            ListNode cur = dummyHead;
            while (cur.next != null) {
                if (cur.next.val == val) {
                    cur.next = cur.next.next;
                } else {
                    cur = cur.next;
                }
            }
            return dummyHead.next;
        }
    }
```
- 注意：
  - 最终返回的一定是**dummyHead.next**，不管之前的头节点是否存在，虚拟节点之后的第一个节点就是新链表的头节点

707.设计链表

题目链接：https://leetcode.cn/problems/design-linked-list/
文章讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：
- 你可以选择使用单链表或者双链表，设计并实现自己的链表。
- 单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
- 如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
- 实现 MyLinkedList 类：
  - MyLinkedList() 初始化 MyLinkedList 对象。
  - int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  - void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  - void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  - void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将不会插入到链表中。
  - void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

代码：

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头节点
    ListNode dummyHead;
    //头节点
    ListNode head = null;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        dummyHead = new ListNode(-1, head);
    }

    // 获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
        // 获取一个遍历指针
        ListNode cur = dummyHead;
        // 如果index非法，返回-1
        if (index >= 0 && index <= size - 1) {
            //从虚拟节点开始寻找，要找到第index的位置，所以是<=
            for (int i = 0; i <= index; i++) {
                cur = cur.next;
            }
            return cur.val;
        } else {
            return -1;
        }
    }

    // 在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    // 在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    // 如果 index 小于0，把index赋值为0，在链表头部插入
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        // 从虚拟节点开始寻找，要找到第index的位置的前一个，所以是<
        // 从前一个开始插数据
        ListNode cur = dummyHead;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = cur.next;
        cur.next = toAdd;
        size++;
    }

    // 删除第index个节点
    // 如果 index 小于0或者大于链表长度，直接终止
    // 如果 index 等于0，
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        // 从虚拟节点开始寻找，要找到第index的位置的前一个，所以是<
        // 从前一个开始删数据
        // 与插入数据保持高度统一，完美！！
        ListNode cur = dummyHead;
        for (int i = 0; i < index ; i++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        size--;
    }
}

206.反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/
文章讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html
题目介绍：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

解法：

解法一：双指针
- 思路：
  - 先提供一个空指针pre和一个指向head的指针cur，如图所示。循环终止的条件是cur找到了原顺序的最后一个null值，在一次循环的过程中完成的操作是：
    - 首先，把**原来顺序的链路径cur.next**保存在一个temp中（我为了方便理解，给它起名为链路径，实际没有这种叫法）(temp = cur.next;)
    - 其次，让cur.next指向pre（cur.next = pre;）
    - 然后，移动pre到cur现在的位置（pre = cur;）
    - 最后，把cur移动原来顺序的下一个位置（cur = temp;）
  - 返回值是新链表的头节点，即pre；
- 代码：
  - ```
  class Solution {
      public ListNode reverseList(ListNode head) {
          ListNode cur = head;
          ListNode pre = null;
          ListNode temp = null;
          while (cur != null) {
              temp = cur.next;
              cur.next = pre;
              pre = cur;
              cur = temp;
          }
          return pre;
      }
  }
```

解法二：递归

思路：递归的思路很简单，就是把最后两步的赋值通过递归函数实现。

代码：

class Solution {
    public ListNode reverseList(ListNode head) {
        // 初次赋值：
        // ListNode cur = head;
        // ListNode pre = null;
        return reverse(head, null);
    }

    public ListNode reverse(ListNode cur, ListNode pre) {
        if (cur == null) {
            return pre;
        }
        ListNode temp = null;
        temp = cur.next;
        cur.next = pre;
        return reverse(temp, cur);
    }
}