代码随想录算法训练营第三天 | 203.移除链表元素、707.设计链表、206.反转链表

学习目标

• 练习链表相关题目

---

学习内容

203. 移除链表元素(Easy)

题目链接:203. 移除链表元素

题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：
输入：head = [], val = 1
输出：[]

示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]

思路：引入虚拟节点，利用curr遍历， prev指向遍历元素的前一个元素，当curr.val == val 时将prev的 next 指针指向curr的下一个元素。
时间复杂度：O(n) 空间复杂度：O(1)

错误实现记录：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode curr = dummy, prev = dummy;
        while(prev!= null && prev.next != null) {
            curr = prev.next;
            if (curr.val == val) {
                prev.next = curr.next;
                curr.next = null;
            }
            prev = prev.next;
        }
        return dummy.next;
    }
}

该实现会在 元素 = [7,7,7,7]，val = 7 时发生错误，应输出[]，事实输出[7,7]
错误分析：
这里很明显，当出现curr.val == val时，删掉那个元素后就直接把下一个元素当做prev了，导致有 curr.val == val且curr.next.val == val时候未经检验就把第二个元素当做了已遍历元素。

解决方案：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode curr = dummy, prev = dummy;
        while(prev!= null && prev.next != null) {
            curr = prev.next;
            while (curr != null && curr.val == val) {
                prev.next = curr.next;
                curr = prev.next;
            }
            prev = prev.next;
        }
        return dummy.next;
    }
}

删除的过程应该是一个循环过程，防止 curr.val == val且curr.next.val == val时curr.next.val == val未经检验。但是这是对上一个方案的打补丁，是上一个方案考虑不周而留下的思维惯性。

更简洁的解决方案：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode curr = head, prev = dummy;
        while(curr != null) {
            if(curr.val == val) {
                prev.next = curr.next;
            } else {
                prev = curr;
            }
            curr = curr.next;
        }
        return dummy.next;
    }
}

上面的方案都是考虑遍历后以prev为基础，即默认每一次遍历后 prev 都会移动到下一个节点。但其实可以以curr为基础，每一次遍历后都是curr遍历到下一个元素，prev由于curr.val是否等于val而有不同的操作。这样代码会简洁很多，速度也更快。

小结：上面的例子表明，在链表中，应该厘清各个变量的功能，主导遍历的应该是curr而不是prev，这样才能在遍历链表过程中实现功能。

707. 设计链表(Middle)

题目链接:707. 设计链表

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

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3

思路：设计有额外头结点的链表，链表属性有: head，tail 以及长度 length。

解决方案：

class MyLinkedList {

    private ListNode head, tail;
    private int length;

    public MyLinkedList() {
        head = new ListNode(-1, null);
        tail = head;
        length = 0;
    }
    
    public int get(int index) {
        if (index >= length) return -1;
        ListNode p = head.next;
        for(int i = 0; i < index; i++) {
            p = p.next;
        }
        return p.val;
    }
    
    public void addAtHead(int val) {
        ListNode p = new ListNode(val);
        p.next = head.next;
        head.next = p;
        length ++;
        if (head == tail) {
            tail = p;
        }
    }
    
    public void addAtTail(int val) {
        ListNode p = new ListNode(val, null);
        tail.next = p;
        tail = p;
        length ++;    
    }
    
    public void addAtIndex(int index, int val) {
        if(index > length) return;
        else if(index == length) {
            addAtTail(val);
        } else if (index <= 0) {
            addAtHead(val);
        } else {
            ListNode tmp = new ListNode(val, null);
            ListNode p = head;
            for(int i = 0; i < index; i++) {
                p = p.next;
            }
            tmp.next = p.next;
            p.next = tmp;
            length ++;    
        }
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= length) return;
        ListNode p = head;
        for(int i = 0; i < index; i++) {
            p = p.next;
        }
        if(p.next == tail) {
            tail = p;
        }
        p.next = p.next.next;
        length --;
    }
}

小结：
这里用了带头结点的链表，且有头结点指针、尾节点的指针和链表长度三个属性。因此，虽然在操作上简便了思考，但是在对链表进行增删的时候也必须额外考虑是否会影响头节点指针、尾节点指针。
举个例子，在addAtHead()中就得考虑链表中没有元素时的情况，deleteAtIndex中必须考虑删除的节点时尾节点时尾节点指针的变化。

206. 反转链表(Easy)

题目链接:206. 反转链表

题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

思路：一般而言链表题都有迭代和递归两种写法，迭代法模式比较固定，一般就是在用prev、curr 、next三个指针分别指向要处理的节点的前一个节点，要处理的节点、要处理的节点的后一个节点，在这基础上进行增加或减少指针。
时间复杂度：O(n) 空间复杂度：O(1)

解决方案：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null, curr = head, next = null;
        while(curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

如果没有事先看过题解，或者有专业的训练，递归法比较难想到。

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

我的想法是，递归应当是从我们接触到的第一层（这里也就是递归的最后一层）进行构思。
先忽略掉if (head == null || head.next == null) return head;这个基线条件。
ListNode newHead = reverseList(head.next)，不要去递归进去想，就把他当成是一个已经完成了逆向的整体，如上图。
那么：head.next.next = head;则会使得：

为什么要head.next = null;?
因为（假设有两个节点），那么由于head.next未置空，它仍然指向newHead，形成了环路。其结果就是，过不了题解。

小结：迭代法套路比较固定，递归法如果熟悉的话，也应当是有一定的套路的，但我并不是太熟悉递归，因此顺便在练习的时候练习递归写法。

---

总结

• 一般而言链表题都有迭代和递归两种写法，迭代法模式比较固定，一般就是在用prev、curr 、next三个指针分别指向要处理的节点的前一个节点，要处理的节点、要处理的节点的后一个节点，在这基础上进行增加或减少指针。
• 递归法也是链表题的重要部分，应当勤加练习