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

203.移除链表元素 

参考文章：代码随想录

参考视频：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili

解题思路：设置一个虚拟头结点来进行删除操作，遍历链表，当指针的next为目标元素时，将指针的next指向指针next的next，从而完成删除操作。

        ListNode dummyhead = new ListNode(0);
        dummyhead.next = head;
        ListNode current = dummyhead;
        while (current.next != null) {
            if (current.next.val == val) {
                current.next = current.next.next;
            } else {
                current = current.next;
            }
        }
        return dummyhead.next;

707.设计链表 

参考文章：代码随想录

参考视频：帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

解题思路：包含了链表的各种基础操作，需要熟练掌握。

int val;
        ListNode next;

        ListNode() {
        }

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

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    static class MyLinkedList {
        int size;
        ListNode head;

        public MyLinkedList() {
            size = 0;
            head = new ListNode(0);
        }

        public int get(int index) {
            if (index < 0 || index >= size) {
                return -1;
            }
            ListNode current = head;
            while(index>=0){
                current=current.next;
                index--;
            }
            return current.val;
        }

        public void addAtHead(int val) {
            addAtIndex(0, val);

        }

        public void addAtTail(int val) {
            addAtIndex(size, val);
        }

        public void addAtIndex(int index, int val) {
            if(index>size){
                return;
            }
            size++;
            ListNode current = head;
            while(index>0){
                current=current.next;
                index--;
            }
            ListNode item = new ListNode(val);
            item.next = current.next;
            current.next = item;
        }

        public void deleteAtIndex(int index) {
            if (index < 0 || index >= size) {
                return;
            }
            size--;
            ListNode current = head;
            while(index>0){
                current=current.next;
                index--;
            }
            current.next = current.next.next;

        }

206.反转链表

 

参考文章：代码随想录

参考视频：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

解题思路：

解法1：双指针法

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。

        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }

        return pre;

解法2：递归

递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可能有的同学会不理解， 可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。

具体可以看代码（已经详细注释），双指针法写出来之后，理解如下递归写法就不难了，代码逻辑都是一样的。

class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
}