代码随想录刷题boot camp第三天 203.移除链表元素 707.设计链表 206.反转链表

代码随想录刷题boot camp第三天 203.移除链表元素 707.设计链表 206.反转链表

203.移除链表元素 题目链接：https://leetcode.cn/problems/remove-linked-list-elements/

这道题比较基础但有很多条件需要考虑进去，设置一个dummy作为虚拟的头节点，将prev指向这个节点（更好操作，相比于传统的将prev赋值为null而言，这样做保证prev.next不会报错），遍历整个链表，需注意当遇到要删除元素的时候直接用prev连接cur的下一个节点就好，此时cur为要删除的节点，否者继续遍历链表，更新prev和cur的指向，注意最后返回的是dummy.next的链表

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

707.设计链表 题目链接：https://leetcode.cn/problems/design-linked-list/

创建一个新的class Listnode，这道题加入一个虚拟节点更好操作，需要注意的点在于对index条件的判断，因为有新的虚拟头结点，按index插入节点的时候需要注意要遍历index+1次，for (int i = 0; i <= index; i++)，找predecessor的时候要遍历index次， for (int i = 0; i < index; i++)，size这个变量要记得维护

class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

206.反转链表 题目链接：https://leetcode.cn/problems/reverse-linked-list/

比较基础但很容易出错，需要掌握迭代和递归两种方法

迭代法：

基础遍历整个链表，用tmp来存cur的下一个节点即可，逻辑就是cur的下一个节点指向prev，然后依次遍历至最后一个节点，注意while结束后cur是null，要返回prev指向的节点

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

递归法：

从迭代法演变而来，base case为while的结束条件，返回条件就是while结束后的返回条件，第一层逻辑就是while里面的逻辑，写好上面两步之后开始递归，封装helper，传入helper的值就是迭代法中给cur和prev赋的值

class Solution {
    public ListNode reverseList(ListNode head) {
        return reverseHelper(head, null);
    }
    private ListNode reverseHelper(ListNode cur, ListNode prev) {
        if (cur == null) return prev;
        ListNode tmp = cur.next;
        cur.next = prev;
        prev = cur;
        cur = tmp;
        return reverseHelper(cur, prev);
    }
}