2023/7/14--代码随想录算法训练营day3 |链表基础、203.移出链表元素、707.设计链表、206.反转链表

链表基础

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

203. 移除链表元素

力扣链接
【状态】：自己写出来了，需要注意，遍历的时候要定义一个临时的指针current，让它指向头结点，操作临时指针current就行，这样最后才能返回整个头结点，但临时指针的改变，原来的链表也会改变
题目：

思路：一旦涉及到头结点的增删，需要想要虚拟头结点 dummy_head = ListNode(next = head)

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        # 创建虚拟头部节点以简化删除过程
        dummy_head = ListNode(next = head)
        
        # 遍历列表并删除值为val的节点
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next   #确认没问题，在走下个一个节点
        
        return dummy_head.next

707. 设计链表

力扣链接
**【状态】：**开始没写出来，但这一道题，值得细细揣摩，多写写！
很考验链表基础操作这道题目设计链表的五个接口：

• 获取链表第index个节点的数值
• 在链表的最前面插入一个节点
• 在链表的最后面插入一个节点
• 在链表第index个节点前面插入一个节点
• 删除链表的第index个节点

题目：

**思路：**1. 单链表：对头结点增删，用虚拟节点dummmy_head

• 单链表中的dummy_head,不算在self.size里面，类似于无实际意义；
• 但是双链表的完全靠head和tail首位指针；另外在遍历index，双链表时间复杂度最多O(self.size//2),属于哪边近跑哪一边

（版本一）单链表法
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:  #获取链表中下标为index的节点的值，若下标无效，返回-1
        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:   #将值为val的节点插入到链表第一个元素前
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1

    def addAtTail(self, val: int) -> None:  #将值为val的节点追加到链表的末尾
        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
        
        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
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

（版本二）双链表法
class ListNode:
    def __init__(self, val=0, prev=None, next=None):
        self.val = val
        self.prev = prev
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        if index < self.size // 2:
            current = self.head
            for i in range(index):
                current = current.next
        else:
            current = self.tail
            for i in range(self.size - index - 1):
                current = current.prev
                
        return current.val

    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val, None, self.head)
        if self.head:
            self.head.prev = new_node
        else:
            self.tail = new_node
        self.head = new_node
        self.size += 1

    def addAtTail(self, val: int) -> None:
        new_node = ListNode(val, self.tail, None)
        if self.tail:
            self.tail.next = new_node
        else:
            self.head = new_node
        self.tail = new_node
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index - 1):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index):
                    current = current.prev
            new_node = ListNode(val, current, current.next)
            current.next.prev = new_node
            current.next = new_node
            self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        if index == 0:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev
            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            current.prev.next = current.next
            current.next.prev = current.prev
        self.size -= 1

206. 反转链表(递归方法值得好好思索品味）

力扣链接
【状态】：刚开始没想到用两个指针，就是一个head，然后在做的时候，发现head到底是指前面已经翻转过的部分，还是后面没有翻转的地方，而且null的问题，出现了混淆。
题目：

思路：

原本是 pre -> cur，要改成 指向 cur —> pre

双指针法： 时间复杂度O(n),空间复杂度O(1)

• 1.先定义一个cur指针，再定义一个pre指针，初始化null
• 2.开始反转，用temp指针保存cur.next节点，然后改变cur.next指向pre，这时已经反转一个节点
• 3.循环（一次循环，改变一个节点方向），不断移动pre，和cur指针（先移动pre，再移动cur）。直至cur指到null，循环结束
• 4.返回pre指针就行
  

 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

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

• 递归的时间复杂度 = 递归调用次数 * 每次递归的时间复杂度
• 递归的空间复杂度 = 递归深度 * 每次递归的空间复杂度

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