刷刷刷Day3| 203.移除链表元素 ，707.设计链表 ，206.反转链表

203.移除链表元素

LeetCode题目要求

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例1
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

解题思路

根据链表的结构，移除链表的一个元素后，实际需要将被删除元素后的元素指向被删除元素的前一个元素
通过一个简单链表结构，并借助虚拟节点，来完成移除元素的操作

/**
 * Definition for singly-linked list.
 * public 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 Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 移除链表的元素，存在3中情况
        //1. 如果被删除的元素是 ‘head’ 节点，那么新的头节点就是 head.next
        //2. 如果被删除的元素是 tail 节点，那么就直接删除了
        //3. 如果呗删除的元素是 中间 节点，那么要指针重新指向，前个节点的 next 为 中间节点的后一个节点

        // 借助一个虚拟头节点，屏蔽掉差异点
        ListNode dummy = new ListNode(-1, head);
        ListNode pre = dummy;
        ListNode curr = pre;
        // 根据 val 删除元素，需要遍历 ListNode
        while (curr != null) {
            if (curr.val == val) {
                //如果找到了目标值，那么把 前个元素的next 指向 当前额下一个元素
                pre.next = curr.next;
            } else {
                //如果未找到，则当前值变成下一个的pre
                pre = curr;
            }
            
            curr = curr.next;
        }
        return dummy.next;
    }
}

重难点

• 借助虚拟节点进行操作，避免删除的是头节点做不必要的处理
• 删除后元素的指针指向
  如 A -> B -> C, 如果删除的是B，那么指针指向变换，A不再指向B，而是指向C，即 A -> C, 这里是需要注意
  附：学习资料链接

707.设计链表

LeetCode题目要求

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
详细的要求可参加设计设计链表的链接

解题思路

设计链表的关键点在于：

• 链表的创建，如果只是一个节点，那么只需要一个 value 即可
• 在头节点前插入节点，相对容易，直接创建一个 node 节点，然后将 next 指向原 head，并 head = node
• 在尾部节点插入节点，这个要考虑链表为空的情况，所以可以分两步，如果链表为空，那么直接创建节点即可；如果不为空，需要遍历链表，直到最后一个，然后加上尾节点
• 如果是在某个索引位置前插入节点时，这要考虑索引位置可能是头部或者是尾部以及是中间位置的情况，当判断出是头部、尾部是直接调用已有方法，当中间位置时先找位置，同时要记录上一节点，这样方便对于插入节点的操作
• 删除操作时，类似中间位置插入节点，主要前节点的记录

单链表

class MyLinkedList {

    ListNode head;
    int size = 0;

    public MyLinkedList() {
    }

    /**
     * 获取链表中第 index 个节点的值。如果索引无效，则返回-1。
     */
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }

        // 链表遍历
        ListNode node = head;
        int i = 0;
        while (node != null) {
            if (i == index) {
                return node.val;
            }
            i++;
            node = node.next;
        }
        return -1;
    }

    /**
     * 在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
     */
    public void addAtHead(int val) {
        ListNode node = new ListNode(val, head);
        head = node;
        size++;
    }

    /**
     * 将值为 val 的节点追加到链表的最后一个元素。
     */
    public void addAtTail(int val) {
        //除了链表为空的情况，直接创建头节点
        if (head == null) {
            head = new ListNode(val);
            size++;
            return;
        }
        ListNode node = head;
        while (node != null) {
            if (node.next == null) {
                node.next = new ListNode(val);
                size++;
                break;
            }
            node = node.next;
        }
    }

    /**
     * 在链表中的第 index 个节点之前添加值为 val 的节点。
     * 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
     * 如果 index 大于链表长度，则不会插入节点。
     * 如果 index 小于0，则在头部插入节点。
     */
    public void addAtIndex(int index, int val) {
        // 如果 index = size, 就放到尾部
        if (index == size) {
            addAtTail(val);
            return;
        }
        // 如果 index > size, 不插入
        // 如果 index < 0, 插入头部
        if (index <= 0) {
            addAtHead(val);
            return;
        }

        if (index < size) {
            ListNode node = head;
            ListNode pre = node;
            for (int i = 0; i < size; i++) {
                ListNode curr = node;
                // 如果找到索引
                if (i == index) {
                    pre.next = new ListNode(val, curr);
                    size++;
                    break;
                }
                pre = curr;
                node = node.next;
            }
        }
    }

    /**
     * 如果索引 index 有效，则删除链表中的第 index 个节点。
     */
    public void deleteAtIndex(int index) {
        if (index < 0 || index > size) {
            return;
        }

        if (index == 0) {
            head = head.next;
            size--;
            return;
        }

        ListNode node = head;
        ListNode pre = node;
        for (int i = 0; i < size; i++) {
            ListNode curr = node;
            // 如果找到索引
            if (i == index) {
                pre.next = curr.next;
                size--;
                break;
            }
            pre = curr;
            node = node.next;
        }
    }
}

class ListNode {
    int val;
    ListNode next;

    public ListNode() {}

    public ListNode(int val) {
        this.val = val;
    }

    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

双向链表

// TODO

重难点

• 对于链表的操作需要记录 size，这里一定在每个操作上有节点数量变化对于 size 的加减操作
• 链表的插入、删除操作对于指针指向的变化是必须要掌握的
  附：学习资料链接

206.反转链表

LeetCode题目要求

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

解题思路

反转比较容易理解，但也会出现一写就废的问题。

• 定义 cur 节点指向头节点；定义 pre 节点，先为 null；定义 tmp 节点，用于临时存储 next 节点，因为反转时如果不记录 next 节点，那么会找不到 next 节点的情况
  以 1->2->3->4->5 列表为例
• 首先记录当前节点的下一个节点，第一次 cur = 1，那么 tmp = 2
• 反转操作，需要将当前 cur.next 指向 pre，即 cur.next = pre ( 1 -> null)
• 此时当前节点变为 pre ，供下一次循环使用 pre = 1
• 下一次的 cur = tmp，这既是第一步需要记录 tmp 的原因
• 最后返回的 pre 节点作为新链表的头节点，因为最后一步是吧 cur 赋值给了 pre，而 cur 变成了 tmp，此时 tmp 已经是空了

/**
 * Definition for singly-linked list.
 * public 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 Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) {
            return head;
        }

        ListNode cur = head; //如： 1
        ListNode pre = null;
        ListNode tmp = null;
        while (cur != null) {
            tmp = cur.next; //保存当前节点的下一个节点， 如 tmp = 2
            cur.next = pre; // 反转，将当前的节点的 next 指向 pre  1 -> null
            pre = cur;   // 将当前节点赋值给 pre ，供一次循环使用 pre = 1
            cur = tmp; // 临时节点赋值给 当前节点 即 cur = 2
        }
        return pre;
    }
}

重难点

个人理解重点在于第一步借助一个 pre = null 的节点，及记录 next 的 tmp 节点，这两部理解里就比较容易反转了
附：学习资料链接