Leetcode刷题笔记3：链表基础1

导语

leetcode刷题笔记记录，本篇博客记录链表基础1部分的题目，主要题目包括：

• 203.移除链表元素
• 707.设计链表
• 206.反转链表

知识点

链表

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链表的入口节点称为链表的头结点也就是head。

常见的链表类型包括：

• 单链表
• 双链表
• 循环链表

单链表中的指针域只能指向节点的下一个节点。双链表中每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。双链表既可以向前查询也可以向后查询。循环链表就是链表首尾相连。

链表的定义

Python中，对于一个链表的节点定义非常简单，只要包含数据和指针字段即可，如：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

Leetcode 203 移除链表元素

题目描述

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

示例 1：

输入： head = [1,2,6,3,4,5,6], val = 6
输出： [1,2,3,4,5]

提示：

• 列表中的节点数目在范围 [0, 104] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

解法

移除一个元素时，比较特殊的情况是移除头结点，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。所以需要单独写一段逻辑处理，代码如下：

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        while head is not None and head.val == val:
            head = head.next
        cur = head
        while cur is not None and cur.next is not None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next

        return head

值得注意的是，在处理头结点时使用了while而不是if，这是为了处理移除头结点后新成为头结点的那个节点值仍是移除值的情况。

这样分情况考虑略显繁琐，这里介绍一种增添虚拟节点的方法，即在头结点前增加一个虚拟的节点，这样原链表中的头结点操作也就和其他节点的操作统一起来了。

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode()
        dummy_head.next = head
        cur = dummy_head
        while cur is not None and cur.next is not None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

Leetcode 707 设计链表

题目描述

你可以选择使用单链表或者双链表，设计并实现自己的链表。单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

• 0 <= index, val <= 1000
• 请不要使用内置的 LinkedList 库。
• 调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

解法

这道题目涵盖了链表的常见操作，仍可以采用设置一个虚拟头结点的方式实现，主要代码如下：

class ListNode:

    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class MyLinkedList:

    def __init__(self):
        self.size = 0
        self.dummy_head = ListNode()


    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
        return current.val


    def addAtHead(self, val: int) -> None:
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1


    def addAtTail(self, val: int) -> None:
        current = self.dummy_head
        while current.next:
            current = current.next
        current.next = ListNode(val)
        self.size += 1


    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return None
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val, current.next)
        self.size += 1


    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return None 
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

由于原题目并没有给我们链表节点的定义，所以这里需要自己定义一下链表节点ListNode。这里的几个易错点为：

• 进行查询、增删时，一定要先判断给定的索引范围；
• 增删完成后，注意及时更新size

Leetcode 206 反转链表

题目描述

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

示例 1：

输入： head = [1,2,3,4,5]
输出： [5,4,3,2,1]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

解法

其实只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表，如图所示:

之前链表的头节点是元素1， 反转之后头结点就是元素5 ，这里并没有添加或者删除节点，仅仅是改变next指针的方向。

双指针解法

我们首先需要定义cur和pre指针，分别指向原始的头结点head（反转后将是最后的节点）和None（反转后原始的head应该指向None）。

之后，使用temp保存一下cur->next，然后循环如下代码逻辑，继续移动pre和cur指针。

            temp = cur.next  # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre # 翻转操作
            # 更新pre 和 cur指针
            pre = cur
            cur = temp

最后，cur 指针已经指向了None，循环结束，链表也反转完毕了。 此时return pre指针就可以了，pre指针就指向了新的头结点。完整的代码如下：

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        cur = head
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        
        return pre

递归解法

递归解法的代码比较简洁，但整体思路与双指针一致。

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def reverse(pre, cur):
            if cur is None:
                return pre
            temp = cur.next
            cur.next = pre
            return reverse(cur, temp)

        return reverse(None, head)

递归的结束条件也是cur指针为空。

参考

• 代码随想录
• 题解