代码随想录算法训练营 Day3 | 链表 | LC.203、LC.206、LC.707

代码随想录算法训练营 Day3 | 链表 | LC.203、LC.206、LC.707

203. 移除链表元素

题目描述：
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
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

半个月前才做过的题，以为能直接秒，结果半个月前做错的思路，这次错的地方还是一模一样！

错误版本

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode pre = dummyHead;
        ListNode cur = head;
        while(cur!=null){
            if(cur.val == val){
                pre.next =cur.next;
            }
            pre=cur;
            cur=cur.next;      
        }
        return dummyHead.next;
    }
}

正确版本 ：仅仅只是一点点细微的差距但结果确实大相径庭！

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode pre = dummyHead;
        ListNode cur = head;
        while(cur!=null){
            if(cur.val == val){
                //如果要删掉当前节点，pre原地不动，删掉当前节点后cur向后移动一个，pre还是cur的前一个结点
                pre.next =cur.next;
            }else{//不需要删的时候pre才移动
                pre=cur;
            }
            //cur无论删不删都要向前移动
            cur=cur.next;
        }
        return dummyHead.next;
    }
}

206. 反转链表

题目描述：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

没啥好说的，经典题，双指针直接秒，
稍微需要注意点的就是头结点也要反转，也就是头结点的下一个结点需要指向null结点

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

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

提示：
所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库。

做过一遍，有思路，但还是一直因为空指针出错，边界需要多注意，有时间再多重写几遍

class ListNode{
    public int val;
    public ListNode next;

    public ListNode(){
    }

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

    public MyLinkedList() {
        size = 0;
        dummyHead = new ListNode(0);
    
    }
    
    public int get(int index) {//index 从0开始
       if (index < 0 || index >=size) {
            return -1;
        }
        ListNode cur = dummyHead;
        index++;
        while(index-->0){
            cur = cur.next;
        }
        return cur.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;
        if (index < 0)index = 0;
        ListNode pre = dummyHead;
        while(index-->0){
            pre = pre.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next = newNode;
        size++;
    }
    
    public void deleteAtIndex(int index) {
      	if (index < 0 || index >=size) return;
        ListNode pre = dummyHead;
        while(index-->0){
            pre = pre.next;
        }
        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);
 */