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

今天的题目感觉最重要的还是弄清楚链表是什么，以及如果实现节点之间的连接。查了很多资料，有一篇文章个人认为解释的很清楚，举例也不错，分享在这里 - 🔗

203.移除链表元素 - 🔗

💡这道题还挺有思路的，想到了可以分两种：一种是创一个新的链表，将符合要求的元素放到链表里；第二种就是在原有链表上操作，但是没有想到有增加虚拟头节点。

方法一：将符合要求的元素创建成新的节点连接到新链表上

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        # 将符合要求的元素创建成新的节点连接到result上
        cur = head
        result = ListNode()
        result_cur = result
        while(cur):
            if cur.val != val:
                node = ListNode()
                node.val = cur.val
                result_cur.next = node
                result_cur = result_cur.next
            cur = cur.next
        
        # 删除实例化产生的头节点
        result = result.next
        return result

这个方法不太好的地方在于，每新增一个节点，就要新建一个内存，空间复杂度会比较高。（个人理解，不是特别懂空间复杂度，有错欢迎纠正！）

方法二：

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
    # 创建虚拟头节点，在原链表上移除元素
        new_head = ListNode() # 创建虚拟头节点
        new_head.next = head #让虚拟头节点指向head
        cur = new_head
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next

        new_head = new_head.next
        return new_head

这个方法比较巧妙的点就在于创建虚拟头节点：倘若不创建虚拟头节点，那么当需要删除第一个节点的时候，就需要让直接让cur指向cur.next，与其他元素处理方式不同，就要分类讨论，比较麻烦。但是创建一个虚拟头节点，那么链表中的所有元素就可以一视同仁了。

707.设计链表 - 🔗

💡这道题个人觉得其实不难，但是由于理解错题目，debug了好久后发现是题目理解错了，中间花费了一两个小时的时间。
问题点：一开始，由于对链表的创建不够熟练，对自己的想法也没有信心，就没有在class MyLinkedList:之外写class ListNode:，错误的以为要直接在class MyLinkedList:里面定义节点，以至于写到后面，直接混淆了节点和链表的概念。误将节点理解成链表，直接将初始化写成了：

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

以至于后面甚至写出了cur = self之类的荒唐语句。看了视频讲解厘清思路后发现，其实这道题无非是要考察节点之间的连接，如何增删改查等。

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

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

    def addAtTail(self, val: int) -> None:
        new_tail = ListNode(val = val)
        cur = self.dummy_head
        for i in range(self.size):
            cur = cur.next
        cur.next = new_tail
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        new_node = ListNode(val = val)
        cur = self.dummy_head
        for i in range(self.size + 1):
            if i == index:
                new_node.next = cur.next
                cur.next = new_node
                self.size += 1
                break
            else:
                cur = cur.next

    def deleteAtIndex(self, index: int) -> None:
        cur = self.dummy_head
        for i in range(self.size):
            if i == index:
                cur.next = cur.next.next
                self.size -= 1
            else:
                cur = cur.next



# 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.反转链表 - 🔗

💡这道题跟203一样，我只想到了一种比较笨且废空间的办法，就是把每个元素取出来，插入新的链表里面。

方法一：暴力解法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        new_dummy_head = ListNode()
        new_cur = new_dummy_head
        cur = head
        while cur:
            node = ListNode(val = cur.val)
            node.next = new_cur.next
            new_cur.next = node
            cur = cur.next
        return new_cur.next

方法二：双指针法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
		pre = None # 前指针
        cur = head # 后指针
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre

方法三：递归法

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)

总结：

1. 遍历链表一般采用两种方法

方法一：当cur遍历到最后一个节点之后，cur = cur.next = None，退出循环

cur = head # 让当前节点cur指向头节点
while cur:
	cur = cur.next
	……

方法二：已知链表长度sizefor i in range(size):

2. 对链表节点的增删改查，可以通过增加虚拟头节点dummy_head来解决，就可以对所有节点一视同仁。

3. 创建完虚拟头节点之后，在返回时注意要返回dummy_head.next。此外，题目中提到的链表元素，一般不包括虚拟头节点，以及初始化产生的那个头节点。