算法训练Day3_链表基础 | LeetCode：203_移除链表元素 + 707_设计链表+59_反转链表

LeetCode：203_移除链表元素

问题描述

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

解决方案：使用虚拟节点，统一节点删除的逻辑

1.思路

• 定义虚拟节点指向head，是的head节点的删除逻辑和其他节点一致；
• 定义临时节点cur指向dummyHead，为了记住dummyHaed的位置，后面要时刻向dummyHead看齐；
• 那么从$cur.next$开始判断是否是要删除的节点元素，不是就继续遍历：$cur=cur.next$；是的话就删除$cur.next$，实际上是让cur的指针指向要删除节点的下一个节点；

2.代码实现

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

3.复杂度分析

时间复杂度：$O(n)$，其中$n$是链表的长度。递归过程中需要遍历链表一次。

空间复杂度：$O(n)$，其中$n$是链表的长度。空间复杂度主要取决于递归调用栈，最多不会超过 $n$层。

4.注意

• 最后记住返回$dummyHead.next$，因为head节点有可能被删除；

5.疑问

LeetCode：707_设计链表

问题描述

Leetcode707题目描述

解决方案：

1.思路：

• 思路很简单，主要是按照题目要求进行实现。

2.代码实现

class MyLinkedList {
    int size;
    ListNode head;

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);

    }

    public int get(int index) {
        if (index < 0 || index >= size)
            return -1;
        ListNode cur = head;
        for (int i = 0; i <= index; i++) {
            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;
        index = Math.max(0, index);
        size++;
        ListNode pre = head;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pre.next;
        pre.next = toAdd;
    }

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

    class ListNode {
        int val;
        ListNode next;

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

3.复杂度分析

• 时间复杂度：查询get，添加addAtIndex，删除deleteAtIndex都是消耗$O(index)$,
• 空间复杂度：所有函数的丹迪调用空间复杂度均为$O(1)$,总体空间复杂度为$O(n)$。其中$n$为$addAtTail，addAtIndex,addAtHead$调用次数之和。

4.注意

• 在查询链表的时候，时间复杂度是$O(n)$,注意边界是小于等于index，因为要取到index这个节点；
• 在index处添加或者节点的时候，注意边界值是小于index，因为要记录前一个节点的指针，才能进行添加或者删除；

4.疑惑：

• 官方的空间复杂度的分析没看懂
• 官方代码，为啥要在最后再次定义一下$ListNode？$为什么不能直接使用$MyLinkedList?$

LeetCode：206_反转链表

问题描述

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

解决方案：

1.思路：

• 迭代思路

2.代码实现

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

3.复杂度分析

• 时间复杂度：$O(n)$，其中$n$是链表的长度。需要遍历链表一次。
• 空间复杂度：$O(1)$。

4.注意

• 初始化pre和cur节点；
• 用一个temp节点去记录指针反转之后，会与后面的链表断了，为防止丢失，要对后面的链表的第一个节点进行记录，这里用temp；