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

1、LeetCode 203.移除链表元素

题目链接：https://leetcode.cn/problems/remove-linked-list-elements/description/
视频链接：https://www.bilibili.com/video/BV18B4y1s7R9
文章链接：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

思路：
对当前节点进行分析：
若与目标值相等，则使得上一结点指向当前节点的下一节点，并将下一节点视为新的当前节点，上一节点不变；
若与目标值不相等，则当前节点变成了下一节点的上一节点，下一节点成为了当前节点。
若当前节点为头结点，则可以设置虚拟节点作为头结点的上一节点，套用上面的判断逻辑。

解答
/**
 * 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) {
        if(head==null) return head;

        ListNode temp = new ListNode(-1,head);//设置虚拟节点作为head的pre节点
        ListNode pre = temp;
        ListNode cur = head;

        while(cur!=null){
            if(cur.val==val){
                pre.next=cur.next;
            }else{
                pre=cur;
            }
            cur=cur.next;
        }

        return temp.next;

    }
}

2. LeetCode 707.设计链表

题目链接：https://leetcode.cn/problems/design-linked-list/description/
视频链接：https://www.bilibili.com/video/BV1FU4y1X7WD
文章链接：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

思路：
链表操作的两种方式：
①直接使用原来的链表来进行操作。
②设置一个虚拟头结点在进行操作。
本题使用虚拟头结点进行操作。解决的关键是正确的获取到想要位置的节点，如：get(int index)是获取到index位置的节点，addAtHead方法的关键是获取到头结点的前驱节点，即虚拟头结点，addAtTail()方法的关键是获取到尾节点，addAtIndex(int index,int val)方法的关键是获取到index的前驱节点，即index-1位置处的节点，deleteAtIndex(index)方法的关键是获取Index的前驱节点。
获取想要位置的节点使用到了虚拟头结点，获取方式如下：

ListNode cur=dumpy;//其中dumpy是虚拟的头节点，其next指向真实的头结点
for(int i=0;i<=index;i++){
     cur=cur.next;
}

该for循环最终获取到的是i最终取到的值的位置处的节点，即，cur=cur.next后的cur节点就是索引i最终位置处的节点。
如：i<=index，cur最终就是index处的节点，i<index，cur最终就是index-1处的节点，也就是index的前驱节点。
注意：这里的index位置是排除虚拟头结点后真实的索引位置，从0开始。

解法如下：
class MyLinkedList {

    //单向链表
    class ListNode{
        int val;
        ListNode next;
        ListNode(int val){
            this.val=val;
        }
    } 
    ListNode dumpy;//虚拟头结点
    int size=0;//链表长度(不包括虚拟头结点)

    public MyLinkedList() {
        dumpy=new ListNode(-1);//初始化创建一个链表
    }
    
    public int get(int index) {
        if(index>=size||index<0){
            return -1;
        }

        ListNode cur=dumpy;

        for(int i=0;i<=index;i++){
            cur=cur.next;
        }//最终获取到了index处的节点

        return cur.val;
    }
    
    public void addAtHead(int val) {
        ListNode newHead = new ListNode(val);
        ListNode temp=dumpy.next;
        dumpy.next=newHead;
        newHead.next=temp;
        size++;
    }
    
    public void addAtTail(int val) {
        ListNode newTail = new ListNode(val);
        ListNode cur=dumpy;
        for(int i=0;i<size;i++){
            cur=cur.next;
        }//最终获取到size-1位置处的节点，即尾节点
        cur.next = newTail;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        if(index<0){
            index=0;
        }
        ListNode pre=dumpy;//前驱节点
        for(int i=0;i<index;i++){
            pre=pre.next;
        }//最终获取到index-1位置处的节点，即index的前驱节点
        ListNode temp=pre.next;
        ListNode newNode=new ListNode(val);
        pre.next=newNode;
        newNode.next=temp;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if(index>=size||index<0){
            return;
        }
        ListNode pre=dumpy;//前驱节点
        for(int i=0;i<index;i++){
            pre=pre.next;
        }//最终获取到index-1位置处的节点，即index的前驱节点
        pre.next=pre.next.next;
        size--;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

3. LeetCode 206.反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/description/
视频链接：https://www.bilibili.com/video/BV1nB4y1i7eL
文章链接：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

思路：
使用双指针方式或递归方式。两者思路一致。需要获取前驱节点pre，当前节点cur，以及临时节点temp。其中temp用来存储当前节点的下一个节点，即cur.next，其不受pre和cur翻转影响。然后pre和cur翻转，之后对其余节点同理接着分析，这时cur就成了前驱节点pre，temp成为了将要分析的当前节点cur，最终返回pre，因为cur最终会为空。

/**
 * 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) {

        ListNode pre=null;
        ListNode cur=head;
        ListNode temp;

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

        return pre;

    }

    // //递归方式
    // public ListNode reverseList(ListNode head) {
    //     return reverse(null,head);
    // }

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

    //     return reverse(cur,temp);
    // }

}