链表Part01

目录

移除链表元素

直接删除法

设置虚拟头节点

设计链表

反转链表

---

移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 

这是一道关于链表删除操作的综合题，包括了删除头节点、尾节点和删除中间的元素。

直接删除法

注意：

• head指向链表中的第一个元素
• 需要先判断链表是否为空，才能进行下面的操作
• 表头元素需要单独处理，因为他没有前一个元素→表中元素处理思路：满足的Node的前一个元素指向Node的后一个元素，把Node略过
•  必须使用循环来保证最终的头节点是不等于val的，才能继续对链表中的元素进行删除操作；否则，如果只用一个if判断头节点，当新的头节点等于val的情况将无法被判断到

# 头节点
# 首先循环找到头节点，然后依次对节点判断即可。
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        while head and head.val == val:
            head = head.next
        if head is None:
            return head
        node = head
        while node.next:
            if node.next.val == val:
                node.next = node.next.next
            else:
                node = node.next
        return head

设置虚拟头节点

• dummy_head = ListNode(next = head)设置虚拟头节点指向原头节点，就可以省去判断头节点的操作了

• 注意返回的是dummy_head.next

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)

        p = dummy_head
        while p.next:
            if p.next.val == val:
                p.next = p.next.next
            else:
                p = p.next
            
        return dummy_head.next

---

设计链表

算是链表的基本操作

可以设置虚拟头节点时操作更方便

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

---

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。

其实只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表。

❗返回的是pre :翻转后，head指向1，head.next=Node，无法遍历得出链表；cur=Node;只有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: 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