【代码随想录刷题笔记 Day 3】203、移除链表元素 | 707、设计链表 | 202、翻转链表

203. 移除链表元素

解题思路

使用虚拟节点

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

难点

• while里面是 curr.next != null，而不是 curr != null
• if 里面是 curr.next.val == val, 而不是 curr.val == val
• if 之后要else ，不能省掉else!!!

---

707、设计链表

解题思路

class ListNode {
   int val;
   ListNode next;

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

class MyLinkedList {
   int size;
   ListNode dummy;
   
   public MyLinkedList() {
       size = 0;
       dummy = new ListNode(0);
   }
   
   public int get(int index) {
       if(index <0 || index >= size){
           return -1;
       }
       ListNode curr = dummy;
       // 查看第index 节点，是要找到第index-1 个节点，然后.next。
       // 但是因为包含一个虚拟头结点，所有仍然找第index个节点
       // 当index = 0 时，返回头结点的val
       for (int i = 0; i <= index; i++) {
           curr = curr.next;
       }
       return curr.val;
   }
   
   public void addAtHead(int val) {
       ListNode newNode = new ListNode(val);
       newNode.next = dummy.next;
       dummy.next = newNode;
       size ++;
   }
   
   public void addAtTail(int val) {
       ListNode newNode = new ListNode(val);
       ListNode curr = dummy;
       while(curr.next != null){
           curr = curr.next;
       }
       curr.next = newNode;
       size++; 
   }
   
   // dummy 相当于是-1的节点， 真实的head是index 为 0的节点。
   public void addAtIndex(int index, int val) {
       if (index < 0){
           index = 0;
       }

       if(index > size){
           return;
       }
       
       
       ListNode curr = dummy;
       ListNode newNode = new ListNode(val);
       for (int i = 0; i < index; i++){
          curr = curr.next;
       }
       
       newNode.next = curr.next;
       curr.next = newNode;

       size++;
   }
   
   public void deleteAtIndex(int index) {
       
       if (index < 0 || index >= size) {
           return;
       }
       size--;
       ListNode curr = dummy;
       for (int i = 0; i < index; i++){
           curr = curr.next;
       }
       curr.next = curr.next.next;

       
   }
}

难点

1. 对index的理解

index可以从0 开始，index为0 指向的是头结点，而虚拟头结点后，虚拟头结点的index 相当于是-1。

2. 边界条件

delete的有效index 是[0, size)
get的有效index 是[0, size)
addatIndex 的有效index是[0,size]

3. 增删时size的改变

记得改变size的值。

---

202、翻转链表

解题思路

1. 双指针

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

2. 递归

 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode curr = head;
        ListNode last = reverseList(curr.next);

        head.next.next = head;
        head.next= null;
        return last;
    }
}

难点

1. 双指针

不需要dummy了，给了head，只需要再定义一个pre指向null

2. 递归

我觉得对于last的指针的理解比较难，最后return的last其实就是初始链表的尾指针，是最里面的reverse函数的输出。