代码随想录算法训练营第三天｜ Leetcode 203, 707, 206

203. Remove Linked List Elements

Given the head of a linked list and an integer val, remove all the nodes of the linked list that has Node.val == val, and return the new head.

We need a dummy node so that we can check the val from the head.

We also need to move two pointers forward together while checking each val in the linked list.

/**
 * 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) {
        ListNode dummy = new ListNode(-1); // don't forget to create a new object
        ListNode cur = head;
        ListNode pre = dummy;
        dummy.next = head;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                pre = pre.next;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

TC: O(n)

SC: O(1)

707. Design Linked List

Design your implementation of the linked list. You can choose to use a singly or doubly linked list.
A node in a singly linked list should have two attributes: val and next. val is the value of the current node, and next is a pointer/reference to the next node.

Implement the MyLinkedList class:

• MyLinkedList() Initializes the MyLinkedList object.
• int get(int index) Get the value of the indexth node in the linked list. If the index is invalid, return -1.
• void addAtHead(int val) Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
• void addAtTail(int val) Append a node of value val as the last element of the linked list.
• void addAtIndex(int index, int val) Add a node of value val before the indexth node in the linked list. If index equals the length of the linked list, the node will be appended to the end of the linked list. If index is greater than the length, the node will not be inserted.
• void deleteAtIndex(int index) Delete the indexth node in the linked list, if the index is valid.

Need to review!

remember to set a dummy node to go through each node.

Q: how is the dummy connected with the head node?

All the linkedlist start from null. We connect the dummy and the head in addAtHead(). 

class MyLinkedList {

    int size;
    ListNode dummy; // set a dummy node

// initiate the Linkedlist
    public MyLinkedList() {
        size = 0;
        dummy = new ListNode(-1);
        
    }
    
    public int get(int index) {
        // don't forget to check the corner case 
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode cur = dummy;
// cur needs to be moved to the node where the index is
        while (index >= 0) {
           cur = cur.next;
           index--;
       } 
       return cur.val;
    }
    
    public void addAtHead(int val) {
        // addAtIndex(0, val);
   
        ListNode newHead = new ListNode(val);
    //Need to point at the old head first, then dummy->newHead 
        newHead.next = dummy.next;
        dummy.next = newHead;
        size++;
    }
    
    public void addAtTail(int val) {
        // addAtIndex(size, val);
        ListNode tail = new ListNode(val);
        ListNode cur = dummy;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = tail;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        // don't forget the corner case
        if (index > size) {
            return;
        }
        ListNode newNode =  new ListNode(val);
        ListNode cur = dummy;
        while (index > 0) {
            cur = cur.next;
            index--;
        }
        newNode.next = cur.next;
        cur.next = newNode;
        size++;
  
    }
    
    public void deleteAtIndex(int index) {
// don't forget the corner case
        if (index >= size) {
            return;
        }
        ListNode cur = dummy;
        while (index > 0) {
            cur = cur.next;
            index--;
        }
        cur.next = cur.next.next;
        size--;
    }
}

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) {
        this.val = val;
    }
}
/**
 * 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);
 */

206. Reverse Linked List

Given the head of a singly linked list, reverse the list, and return the reversed list.

when you reverse a linked list, you need to make sure that the next pointer of the last node (the original head) is set to null. This ensures that the reversed list terminates properly, and it doesn't form a cycle.

/**
 * 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) {
        if (head == null) {
            return null;
        }
        ListNode cur = head;
        ListNode pre = null; //The initialization of pre is missing, leading to a compilation error.
        
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

TC: O(n)

SC:O(1)