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

链表理论

定义链表

# 定义命名为ListNode的类，包含数据属性和方法
class ListNode:

	# 类ListNode的构造函数（也称初始化方法），在创建类的实例时自动调用
    def __init__(self, val, next=None):
	
		# 将构造函数参数 val 的值赋给对象的 val 属性，存储节点的值
        self.val = val

		# 将构造函数参数 next 的值赋给对象的 next 属性，将存储指向下一个节点的引用。如果不提供 next 参数，它将默认为 None，表示没有下一个节点
        self.next = next

链表的操作

删除节点

若要删除此节点，只要将上一节点的next指针指向下一节点就可以了

添加节点

若要在两个节点之间添加一个节点，只需要把第一节点的next指针指向新添加的节点，再将新添加节点的指针指向原本的第二个节点就可以了

链表和数组的性能分析

	插入/删除 时间复杂度	查询 时间复杂度	适用场景
数组	O(n)	O(1)	数据量固定，频繁查询，较少增删
链表	O(1)	O(n)	数据量不固定，频繁增删，较少查询

leetcode 203

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

移除链表元素

方法一：原链表删除元素

重点

情况一：要删除的节点是头节点

在删除头节点的时候，要用 while而不是if。因为有一种情况：除了头节点以外，第二个节点也是val值。这时就需要持续删除。但if只删除一次。

情况二：要删除的节点不是头节点

注意再循环中，current指针一定从头节点开始。因为在单向链表中，不记录上一个节点，只能找到下一个节点。所以要想删除某个节点，一定是删除current的next节点，再将current的下一个节点设置成current的next的next。

完整python版答案

# 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]:
        # 删除头结点
        while head is not None and head.val == val:
            tmp = head
            head = head.next
            del tmp  # 释放节点

        # 删除非头结点
        cur = head
        while cur is not None and cur.next is not None:
            if cur.next.val == val:
                tmp = cur.next
                cur.next = cur.next.next
                del tmp  # 释放节点
            else:
                cur = cur.next
        return head

方法二：虚拟头节点

重点

• 和前一个方法一样，注意current = dummy_head
• 注意return的是dummy_head.next，因为前面加了虚拟头节点，并且原先的head可能已经被删了

完整python版答案

# 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_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

leetcode 707

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

设计链表

统一使用虚拟头节点的方法

获取第n个节点的数值

有两种方法：

while循环

while n:
	current = current.next
	n -= 1

for循环

for i in range(index):
	current = current.next

头部插入节点

易出现问题：如果dummyhead指向newnode的话，之前的head节点就找不到了。
所以应该先让newnode指向head，建立这条边，再将dummyhead指向newnode。

尾部插入节点

用while遍历链表时，到达尾部节点的条件：current.next是null。找到后将current.next指向新节点即可。

第n个节点前插入

要想在第n个节点前插入，就需要知道第n个节点之前的那个节点，即第n-1个。所以第n个节点即current.next，第n-1个节点即current。
建立边的顺序同头部插入节点。

删除第n个节点

同样的，要删除第n个节点current.next，就需要知道第n-1个节点current，之后将current指向current.next.next即可。

完整python版答案：单链表

（版本一）单链表法
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
        
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
            
        return current.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:
        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


# 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)

完整python版答案：双链表

（版本二）双链表法
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



# 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)

leetcode 206

leetcode题目链接
代码随想录文章讲解
代码随想录视频讲解

反转链表

方法一：双指针

重点

1. 初始化：

current = head
pre = null

2. 循环结束：
   当current指向null的时候

3. 临时节点
   要设置临时节点temp，在curren.next没有重新赋值的时候把原本的curren.next保存下来。

4. 循环中的移动
   每次将pre和current向后移动的时候，注意顺序：要先把current赋给pre，再将temp赋给current

5. 最后应该return的是pre

完整python版答案

# 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: 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

方法二：递归法

重点（待补充）

完整python版答案

# 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: 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)