Day3 | 203.移除链表元素 、707.设计链表 、 206.反转链表

203.移除链表元素

建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.移除链表元素.html

思考

设置一个虚拟的dummy节点，方便代码逻辑一致，不然要专门处理头节点。
定义一个pre节点，作为cur节点的前驱节点，方便指针重连。新手不建议用cur.next.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 removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode()
        dummy.next = head
        cur = head
        pre = dummy
        while cur:
            if cur.val == val:
                pre.next = cur.next
                cur = cur.next
            else:
                pre = cur
                cur = cur.next
        return dummy.next

707.设计链表

建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点

题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.设计链表.html

思考

很经典的考察链表操作的题目，需要设置一个虚拟头节点便于操作。同时，增加一个链表长度的值，可以方便各种使用index的函数的判断。
注意 需要在外面先实现一个链表的结构。

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

class MyLinkedList:

    def __init__(self):
        # 虚拟头结点，方便操作
        self.dummy = ListNode()
        self.len = 0
    def get(self, index: int) -> int:
        cur = self.dummy.next
        while index > 0 and cur:
            cur = cur.next
            index-=1
        if cur:
            return cur.val
        else:
            return -1
            
    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)

    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self.len, val)

    def addAtIndex(self, index: int, val: int) -> None:
        new_node = ListNode(val)
        cur = self.dummy.next
        pre = self.dummy
        temp_index = index
        while index > 0 and cur:
            cur = cur.next
            pre = pre.next
            index-=1
        # 此时cur就是第index个，插入
        if cur or temp_index == self.len:
            new_node.next = cur
            pre.next = new_node
            self.len+=1

    def deleteAtIndex(self, index: int) -> None:
        cur = self.dummy.next
        pre = self.dummy
        while index > 0 and cur:
            cur = cur.next
            pre = pre.next
            index-=1
        # 此时cur就是第index个，删除
        if cur:
            pre.next = cur.next
            self.len-=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)

206.反转链表

建议先看我的视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.翻转链表.html

思考

翻转链表，刷题领域的abandon了，之前校招面试手撕的第一题，估计这家公司现在已经倒闭了。。
需要设置一个pre节点，指向新链表的头结点，用于遍历cur过程中断开指针 再 链接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]:
        pre = None
        cur = head
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

递归写法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
def reverse(pre,cur):
    if cur is None:
        return pre
    # 指针换向
    temp = cur.next
    cur.next = pre
    # 递归的传参 等价于双指针写法中的
    # pre = cur
    # cur = temp
    return reverse(cur,temp)
    
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        cur = head
        return reverse(pre,cur)