代码随想录-DAY3|203.移除链表元素、707.设计链表、206.反转链表

203. 移除链表元素

leetcode链接：移除链表元素

文档讲解：移除链表元素

视频链接：代码随想录-移除链表元素

状态：没用虚拟头节点的方式实现了，补充下虚拟头节点的思路

非虚拟头结点方式

思路：

1、首先要区分两种情况，删除节点是否是头结点；为什么要区分这两种情况，因为这是个单向链表，删除节点必须要知道该节点的前一个节点，但是头结点不存在前一个节点，所以要区分情况；

2、如果不是删除头结点，则借助一个临时节点来操作链表，其中比较关键的在于当temp.next.val == val时，temp.next = temp.next.next;因为这是个单向链表，删除的话，需要通过操作删除节点的前一个元素来进行移除；

3、如果删除元素恰好是头结点，则直接把头结点的下个元素设置成头结点即可；

代码:

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode temp = head;
        while (temp != null) {
            if (temp == head && head.val == val) { //如果移除元素是头结点
                head = temp.next;
                temp = head;
            } else {
                if (temp.next != null && temp.next.val == val) { //移除该节点
                    temp.next = temp.next.next;
                } else {
                    temp = temp.next;
                }
            }
        }
        return head;
    }
}

虚拟头结点方式（推荐）

思路：

1、用非头节点方式实现的时候，需要分两种情况，因为头节点没有前一个节点，导致需要分情况处理；如果再增加一个虚拟头结点dummyNode，来让dummyNode.next=head; 这样如果从dummyNode节点开始遍历整个数组，不管移除头节点还是非头节点，都可以用统一的规则处理；

2、注意：最后返回，不能将head返回，而是要将dummyNode.next进行返回，因为head节点有可能已经被删除；

代码：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyNode = new ListNode();
        dummyNode.next = head;
        ListNode temp = dummyNode;
        while (temp != null) { //初始dummyNode已经实例化过，不为null
            if (temp.next != null && temp.next.val == val) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
        return dummyNode.next;
    }
}

707. 设计链表

leetcode链接：设计链表

文档讲解：设计链表

视频链接：代码随想录-设计链表

状态：调试的头皮发麻

思路：

单链表实现：图不画了，数据结构都是链表基础，考验代码编写能力，注意看清题意，注意边界问题，就是调试起来头皮发麻 -_- , 总感觉有并发风险，手贱加的synchronized；

1、头结点不存储值，做了上一题之后，吸取的教训，所以采用虚拟头结点的方式方便删除元素和添加元素；

2、删除和插入元素，需要先找到操作元素的前一个元素；插入和删除操作之后，必须更新容量size；

代码:

class MyLinkedList {

    static class Node {
        int val;
        Node next;
        public Node() {
        }
        public Node(int val, Node next) {
            this.val = val;
            this.next = next;
        }
    }

    //规定头节点不存储数据
    Node head;
    int size = 0;

    public MyLinkedList() {
        head = new Node(-1, null);
    }
    
    public int get(int index) {
        if (size == 0 || index > size-1) {
            return -1;
        }
        Node temp = head;
        for (int i = 0; i <= index; i++) {
            temp = temp.next;
        }
        return temp.val;
    }
    
    public void addAtHead(int val) {
        synchronized (head) {
            if (size == 0) { //如果链表此时为空
                head.next = new Node(val, null);
                size++;
                return;
            }
            Node temp = head.next;
            //如果链表不为空
            Node newNode = new Node(val, temp);
            head.next = newNode;
            size++;
        }
    }
    
    public void addAtTail(int val) {
        synchronized (head) {
            if (size == 0) { //如果链表此时为空
                head.next = new Node(val, null);
                size++;
                return;
            }
            Node temp = head;
            while(temp.next != null) {
                temp = temp.next;
            }
            //当temp.next为0时；
            temp.next = new Node(val, null);
            size++;
        }
    }
    
    public void addAtIndex(int index, int val) {
        synchronized (head) {
            if (index > size) {
                return;
            }
            if (size == 0) { //如果链表此时为空
                head.next = new Node(val, null);
                size++;
                return;
            }
            if (index == size) {//加到链表的末尾
                Node temp = head;
                while(temp.next != null) {
                    temp = temp.next;
                }
                //当temp.next为0时；
                temp.next = new Node(val, null);
                size++;
                return;
            }
            //都不是的话，先找到index的前一个元素；
            Node temp = head;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            Node indexNode = temp.next;
            Node newNode = new Node(val, indexNode);
            temp.next = newNode;
            size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        synchronized (head) {
            if (size == 0 || index > size-1) {
                return;
            }
            Node temp = head;
            //找到要删除元素的前一个元素；
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            //找到之后
            temp.next = temp.next.next;
            size--;
        }
    }
}

206. 反转链表

leetcode链接：反转链表

文档讲解：反转链表

视频链接：代码随想录-反转链表

状态：做完前两题，这题就不难了，我理解成就是原链表依次移除元素，将元素依次插入到新链表的第一个位置；

思路：

1、参照前两题，来一个虚拟头节点dummyHead，定义规则，每从原链表遍历到一个元素就放入dummyHead的下一个节点；

2、创建一个临时指针temp指向head；然后将head指向head.next（方便移到原链表的下一个节点）;然后将temp插入到dummyHead的下一个节点即可；

代码:

class Solution {
    public ListNode reverseList(ListNode head) {
        //新创建一个虚拟头节点，每遍历到一个元素，插入到这个头节点的下一个元素；
        ListNode dummyNode = new ListNode();
        while (head != null) {
            ListNode temp = head;
            head = head.next;
            temp.next = dummyNode.next;
            dummyNode.next = temp;
        }
        return dummyNode.next;
    }
}