算法记录 | Day3链表基础

 203-移除链表元素

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

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

输出：[1,2,3,4,5]

解题思路

• 单链表中移除头结点 和 移除其他节点的操作方式不一样，可以直接使用原来的链表，分开处理 或者 设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除
• 若直接使用原来的链表来进行移除，头结点移除其实只要将头结点向后移动一位

虚拟头结点法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        # 1. 虚拟头结点
        # 创建虚拟头部结点以简化删除过程
        dummy_head = ListNode(next = head);
        
        # 遍历列表并删除值为val的结点
        cur = dummy_head;
        while cur.next != None: # 链表如果报cur没定义注意有可能是指向None了
            if cur.next.val == val:
                cur.next = cur.next.next;
            else: # 删掉一个的话则不需要移
                cur = cur.next;
        return dummy_head.next

• 时间复杂度: O(n)
• 空间复杂度: O(1)

难点

• 链表结点定义，虚拟头结点写法
• 边界条件：可想想极端情况，如只有一个结点 

 总结

虚拟头结点可以使得所有结点用统一逻辑处理；while遍历时报cur没定义，注意链表如果报这个错有可能是循环中指向None了，这种时候可以代入一组数据推一推哪儿出了问题。

707-设计链表

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

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

输入

["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]

[[], [1], [3], [1, 2], [1], [1], [1]]

输出

[null, null, null, null, 2, null, 3]

解释

MyLinkedList linkedList = new MyLinkedList();

linkedList.addAtHead(1);

linkedList.addAtTail(3);

linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3

linkedList.get(1); //返回2

linkedList.deleteAtIndex(1); //现在链表是1-> 3

linkedList.get(1); //返回3

解题思路

• 链表的基本操作，可设置虚拟头结点简化逻辑

单链表虚拟头结点法

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

class MyLinkedList:

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

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1;

        cur = self.dummy_head.next;
        for i in range(index):
            cur = cur.next;
        return cur.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:
        cur = self.dummy_head;
        while cur.next:
            cur = cur.next;
        cur.next = ListNode(val);
        self.size += 1;

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return;

        cur = self.dummy_head;
        for i in range(index):
            cur = cur.next;
        cur.next = ListNode(val,cur.next);
        self.size += 1;

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return;
        # 删除/添加都需要前一个结点，因此cur应为前一个结点
        cur = self.dummy_head;
        for i in range(index):
            cur = cur.next;
        cur.next = cur.next.next;
        self.size -= 1;

# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

总结

注意__init__中的写法：链表结点和链表的定义（虚拟头结点和size）。

画图理思路时确认：① cur是哪个 ② 边界条件（结合极端情况）③ 操作先后顺序（防丢失）

206-反转链表

题目：给你单链表的头节点 head ，请反转链表，并返回反转后的链表。输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

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

输出：[5,4,3,2,1]

解题思路 

• 只需要改变链表的next指针的指向，直接将链表反转
• 双指针法：首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。开始反转，要把 cur->next 节点用tmp指针保存一下，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre 。
• 递归法：逻辑一样，可基于双指针法改写。

双指针法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 1. 双指针法
        pre = None;
        cur = head;
        # 边界条件注意最后一个要挂上
        while cur:
            temp = cur.next;
            cur.next = pre;
            # 先移pre再移cur
            pre = cur;
            cur = temp;
        return pre

注意：先移动pre，在移动cur

• 时间复杂度: O(n)
• 空间复杂度: O(1)

递归法 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 2.递归
        return self.reverse(None,head); # 初始化

    def reverse(self, pre: ListNode, cur: ListNode)->ListNode:
        #边界条件和返回值
        if cur==None:
            return pre
        temp = cur.next;
        cur.next = pre;
        return self.reverse(cur, temp);
            

• 时间复杂度: O(n), 要递归处理链表的每个节点
• 空间复杂度: O(n), 递归调用了 n 层栈空间

总结

链表查询O(n)，增删O(1)；数组查询O(1)，增删O(n)，因为内存地址连续

在链表中双指针常用来记录前驱和后继节点。

双指针法是基础，理解了递归就好写了，逻辑是一样的。

画图理思路时确认：① cur是哪个 ② 边界条件（结合极端情况）③ 操作先后顺序（防丢失）