代码随想录算法训练营第3天—链表01 | 203.移除链表元素、707.设计链表、*206.反转链表

203.移除链表元素

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

• 考点
  • 虚拟头节点
• 我的思路
  • 头节点和其它节点分开讨论
• 视频讲解关键点总结
  • 未看视频
  • 在头节点前创建一个虚拟头节点指向头节点
  • 之后创建循环所用链表变量prev，并将虚拟头节点赋值给prev
  • 开始循环，循环条件为prev.next不为None
  • 进入循环，如果prev.next.val == val，则让prev.next = prev.next.next，否则，让prev变成prev.next
  • 最后输出虚拟头节点所指向的头节点即为答案
• 我的思路的问题
  • 头节点和其它节点分开讨论会增加算法的时间复杂度
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dummy_node = ListNode(next=head)
        prev = dummy_node
        while prev.next is not None:
            if prev.next.val == val:
                prev.next = prev.next.next
            else:
                prev = prev.next
        return dummy_node.next

707.设计链表

题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

• 考点
  • 链表的虚拟头节点
• 我的思路
  • 链表类初始化头节点和链表长度
  • 之后如果需要用到虚拟头节点，在每个实现方法里创建虚拟头节点
• 视频讲解关键点总结
  • 未看视频
  • 关键点在于类初始化里直接初始化虚拟头节点和链表长度，不初始化头节点
• 我的思路的问题
  • 在删除节点的时候，如果删除的是头节点，则我用新创建的虚拟头节点就无法成功删除，必须要按照类初始化里初始化虚拟头节点的方式才行
• 代码书写问题
  • 无
• 可执行代码

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


# leetcode submit region begin(Prohibit modification and deletion)
class MyLinkedList(object):

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

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        n = 0
        prev = self.dummy_head
        while prev.next is not None:
            if n == index:
                return prev.next.val
            else:
                n += 1
                prev = prev.next
        return -1


    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.dummy_head.next = ListNode(val=val, next=self.dummy_head.next)
        self.length += 1


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        new_last = ListNode(val=val)
        prev = self.dummy_head
        while prev.next is not None:
            prev = prev.next
        prev.next = new_last
        self.length += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index > self.length:
            return
        n = 0
        new_node = ListNode(val=val)
        prev = self.dummy_head
        while prev.next is not None:
            if n == index:
                new_node.next = prev.next
                prev.next = new_node
                self.length += 1
                return new_node
            else:
                n += 1
                prev = prev.next
        if n == index:
            prev.next = new_node
            self.length += 1
            return new_node
        return -1



    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        n = 0
        prev = self.dummy_head
        while prev.next is not None:
            if n == index:
                prev.next = prev.next.next
                self.length -= 1
                return 0
            else:
                n += 1
                prev = prev.next
        return -1

*206 反转链表

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

• 考点
  • 法一：双指针
  • 法二：基于双指针的解法改为对应的递归函数
• 我的思路
  • 无思路
• 视频讲解关键点总结
  • 法一：双指针
    • prev指针从NULL开始，cur从head开始
    • 创建一个临时变量a保存cur的next
    • 让cur的next等于prev
    • 让prev等于cur
    • 让cur等于a
  • 法二：递归（结合法一看，其实就是对双指针法的递归实现）
    • 递归函数的功能：输入两个指针prev和cur，返回反转后链表的头指针；为此，函数体内进行cur节点重定向的操作
    • 递归结束条件，cur移动到最后一个节点
• 我的思路的问题
  • 没想到用一个初始化为NULL的prev
• 代码书写问题
  • 无
• 可执行代码
• 法一：双指针法

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur = head   
        pre = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp
        return pre

• 法二：递归法

class Solution(object):
    def rev(self, prev, cur):
        if cur is None:
            return prev
        temp = cur.next
        cur.next = prev
        return self.rev(cur, temp)
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        return self.rev(None, head)