【力扣】链表操作

基础操作

反转链表

206. 反转链表
头插法

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        dummy = ListNode()
        while head:
            node = head
            head = head.next
            node.next = dummy.next
            dummy.next = node
        return dummy.next

合并链表

21. 合并两个有序链表
同时存在则判断 一个不存在就把另一个尾巴拿过来

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = head = ListNode()
        while list1 and  list2:
            if list1.val < list2.val:
                node = list1
                list1 = list1.next 
            else:
                node = list2
                list2 = list2.next
            dummy.next = node
            dummy = dummy.next
        dummy.next = list1 if list1 else list2
        return head.next
            

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        head = ListNode()
        j = head

        while list1 and list2:
            if list1.val < list2.val:
                j.next = list1
                list1 = list1.next
            else:
                j.next = list2
                list2 = list2.next
            j = j.next
        j.next = list1 if list1 else list2
        return head.next

快慢指针

环形链表

141. 环形链表

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False
        fast ,slow = head.next, head
        while fast and fast.next:
            if fast == slow:
                return True
            fast = fast.next.next
            slow = slow.next
        return False

142. 环形链表 II

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast = slow = head
        if not head : return 
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast : break
        if not fast or not fast.next:
            return
        fast = head
        while fast != slow:
            slow = slow.next
            fast = fast.next
        return fast

160. 相交链表
[1,2,3,7,4,5,6,3]
[4,5,6,3,7,1,2,3]

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        q = headA
        p = headB
        while p != q:
            q = q.next if q else headB
            p = p.next if p else headA
        return q

综合操作

109. 有序链表转换二叉搜索树
结合了找到中位数和二叉树的建立操作，注意链表是不切断的，只用指针来确定位置

class Solution:
    def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:
        def findmid(left,right):
            fast = slow = left
            while fast!= right  and fast.next != right:
                slow = slow.next
                fast = fast.next.next
            return slow
        def travel(left,right):
            if left == right:
                return 
            mid = findmid(left,right)
            node = TreeNode(mid.val)
            node.left = travel(left,mid)
            node.right = travel(mid.next,right)
            return node
        return travel(head,None)

将中间切断 反转链表 和并联表这种基本操作归为一题
143. 重排链表

class Solution:
    def reorderList(self, head: ListNode) -> None:
        """
        Do not return anything, modify head in-place instead.
        """
        def merge(link1,link2):
            dummy= head = ListNode()
            while link1 and link2:
                dummy.next = link1
                link1 = link1.next
                dummy = dummy.next

                dummy.next = link2
                link2 = link2.next
                dummy = dummy.next
            dummy.next = link1 if link1 else link2
            return head.next
        def reverse(link1):
            dummy = ListNode()
            while link1:
                node = link1
                link1 = link1.next
                node.next =dummy.next
                dummy.next = node
            return dummy.next
        def cut(link):
            fast = slow = link
            while fast and fast.next:
                slow = slow.next
                fast = fast.next.next
            mid = slow
            link2 = slow.next
            mid.next = None
            return link,link2
        link1, link2 = cut(head)
        link2 = reverse(link2)
        res = merge(link1,link2)
        return res

92. 反转链表 II
dummy is all you need

class Solution:
    def reverseBetween(self, head: ListNode, left: int, right: int) -> ListNode:
        def reverseLink(link):
            dummy = head = ListNode()
            tail = link
            while link:
                node = link
                link = link.next
                node.next = dummy.next
                dummy.next = node
            return head.next,tail
        i = 0
        dummy = ListNode()
        dummy.next = head
        p = dummy
        while i < right :
            if i == left - 1:
                link1_tail = p
                link2 = p.next
                p.next = None
                p = link2
                i += 1
                continue
            i += 1
            p = p.next
        link3 = p.next if p else None
        if p :
            p.next = None 
        # print(head,link1_tail,link2,link3)
        link2, link2_tail= reverseLink(link2)
        
        link1_tail.next = link2
        link2_tail.next = link3
        return dummy.next