Day3 | 链表基础 203.移除链表元素 / 707.设计链表 / 206.反转链表

Leetcode 203.移除链表元素

题目链接：203.移除链表元素

思路：

因为头节点也可能被删除，为了操作的统一性，想到了添加一个dummy节点（虚拟头结点）。

解题：成功

代码实现

/**
 * 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, head);
        ListNode p1 = dummy;
        ListNode p2 = head;

        while(p2 != null){
            if(p2.val == val){
                p1.next = p2.next;            
            }
            else{
                p1 = p2;
            }
            p2 = p2.next;
        }
        return dummy.next;
    }
}

Leetcode 707.设计链表

题目链接：707.设计链表

思路：

这道题目把链表常见的五个操作都覆盖了。用dummy节点会简单一点，否则添加、删除操作都需要修改头指针的位置，而如果引入dummy节点，头指针可以一直指向dummy节点，不用修改。

解题：成功

代码实现

class MyLinkedList {

    class Node{
        int val;
        Node next;

        public Node(int val){
            this.val = val;
            this.next = null;
        }
    }
    
    int size;
    Node dummyHead;

    public MyLinkedList() {
        size = 0;
        dummyHead = new Node(-1);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        Node cur = dummyHead.next;
        while(index > 0){
            cur = cur.next;
            index--;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        Node node = new Node(val);
        node.next = dummyHead.next;
        dummyHead.next = node;
        size++;
    }
    
    public void addAtTail(int val) {
        Node cur = dummyHead;
        while(cur.next != null){
            cur = cur.next;
        }
        cur.next = new Node(val);
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        Node cur = dummyHead;
        while(index > 0){
            cur = cur.next;
            index--;
        }
        Node node = new Node(val);
        node.next = cur.next;
        cur.next = node;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        Node cur = dummyHead;
        while(index > 0){
            cur = cur.next;
            index--;
        }
        cur.next = cur.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);
 */

Leetcode 206.反转链表

题目链接：206.反转链表

思路：

之前写过这道题。面试中常考的题。

解题：成功

代码实现

方法一：从前向后双指针

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

方法二：从后向前递归

/**
 * 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 || head.next == null){
            return head;
        }
        ListNode last = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }
}

方法三：从前向后递归，和双指针写法类似，略

总结

链表题目写while循环条件的时候，可以直接代入特殊案例去判断这样写是否会有空指针异常等错误出现。还可以根据最终 cur 指针应该停在什么位置，来编写循环条件，比如要在链表尾部添加元素，那么很容易想到循环条件应该是 cur.next != null，因为只有 cur 指针指向链表最后一个元素，才可以操作该元素的指针，使其指向新元素。