链表相关的经典leetcode题

链表
链表两数之和
'''
链表两数之和
'''


# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 初始化进位为0
        carry = 0
        # 创建一个哑节点作为结果链表的头节点
        dummy = ListNode()
        # 创建一个指针指向哑节点
        current = dummy

        # 遍历两个链表，直到其中一个链表为空
        while l1 or l2:
            # 如果l1不为空，则获取其值，否则使用0代替
            x = l1.val if l1 else 0
            # 如果l2不为空，则获取其值，否则使用0代替
            y = l2.val if l2 else 0
            # 计算当前节点的值和进位
            sum = x + y + carry
            # 更新进位
            carry = sum // 10
            # 创建新节点，并将其添加到结果链表中
            current.next = ListNode(sum % 10)
            # 移动指针到下一个节点
            current = current.next
            # 如果l1不为空，则移动l1指针到下一个节点
            if l1:
                l1 = l1.next
            # 如果l2不为空，则移动l2指针到下一个节点
            if l2:
                l2 = l2.next

        # 如果最后还有进位，则添加一个新节点表示进位
        if carry > 0:
            current.next = ListNode(carry)

        # 返回结果链表的头节点（哑节点的下一个节点）
        return dummy.next


反转链表


'''
反转链表
'''


# 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:
        # 初始化前一个节点为None，当前节点为head
        prev = None
        current = head

        # 遍历链表，直到当前节点为空
        while current:
            # 保存当前节点的下一个节点
            next_node = current.next
            # 将当前节点的下一个节点指向前一个节点
            current.next = prev
            # 将前一个节点更新为当前节点
            prev = current
            # 将当前节点更新为下一个节点
            current = next_node

        # 返回反转后的链表头节点（即原链表的尾节点）
        return prev
合并两个有序链表

'''
合并两个有序链表
'''


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 创建一个哑节点作为结果链表的头节点
        dummy = ListNode()
        # 创建一个指针指向哑节点
        current = dummy

        # 遍历两个链表，直到其中一个链表为空
        while l1 and l2:
            # 如果l1的值小于等于l2的值，则将l1节点添加到结果链表中，并将l1指针移动到下一个节点
            if l1.val <= l2.val:
                current.next = l1
                l1 = l1.next
            # 否则，将l2节点添加到结果链表中，并将l2指针移动到下一个节点
            else:
                current.next = l2
                l2 = l2.next
            # 移动指针到下一个节点
            current = current.next

        # 如果l1不为空，则将其剩余部分添加到结果链表中
        if l1:
            current.next = l1
        # 如果l2不为空，则将其剩余部分添加到结果链表中
        if l2:
            current.next = l2

        # 返回结果链表的头节点（哑节点的下一个节点）
        return dummy.next

检测链表中有没有环
'''
检测链表中有没有环
'''


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        # 使用快慢指针进行检测
        slow = head
        fast = head

        while fast and fast.next:
            # 慢指针每次移动一个节点
            slow = slow.next
            # 快指针每次移动两个节点
            fast = fast.next.next
            # 如果快慢指针相遇，则存在环
            if slow == fast:
                return True

        # 如果快指针到达链表尾部，则不存在环
        return False
链表中下一个更大的元素
'''
链表中下一个更大的元素
'''
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def nextGreaterElements(self, head: ListNode) -> List[int]:
        # 初始化结果列表和单调递减栈
        result = []
        stack = []
        # 将链表转换为数组，方便处理循环链表的情况
        nums = []
        while head:
            nums.append(head.val)
            head = head.next
        n = len(nums)
        # 遍历数组两次，以处理循环链表的情况
        for i in range(2 * n):
            num = nums[i % n]
            # 当栈非空且当前元素大于栈顶元素时，弹出栈顶元素并记录下一个更大元素
            while stack and num > nums[stack[-1]]:
                result[stack.pop()] = num
            # 将当前元素的索引入栈，以便后续比较大小
            stack.append(i % n)
            # 如果当前元素没有下一个更大元素，则记录为-1
            if i < n:
                result.append(-1)
        return result
旋转链表

'''
旋转链表
'''
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def rotateRight(head, k):
    if not head or not head.next:
        return head

    # 计算链表长度
    length = 1
    cur = head
    while cur.next:
        cur = cur.next
        length += 1

    # 计算实际需要旋转的次数
    k %= length
    if k == 0:
        return head

    # 找到新的头节点和尾节点
    new_tail = head
    for _ in range(length - k - 1):
        new_tail = new_tail.next
    new_head = new_tail.next

    # 将尾节点的next置为空，实现链表的旋转
    new_tail.next = None
    cur.next = head

    return new_head



'''
合并k个升序链表
'''
import heapq

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

def mergeKLists(lists):
    dummy = ListNode()
    cur = dummy
    heap = []

    # 初始化堆
    for i in range(len(lists)):
        if lists[i]:
            heapq.heappush(heap, (lists[i].val, i))
            lists[i] = lists[i].next

    # 合并链表
    while heap:
        val, idx = heapq.heappop(heap)
        cur.next = ListNode(val)
        cur = cur.next
        if lists[idx]:
            heapq.heappush(heap, (lists[idx].val, idx))
            lists[idx] = lists[idx].next

    return dummy.next


删除倒数第n个节点
'''
删除倒数第n个节点
'''
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def removeNthFromEnd(head, n):
    dummy = ListNode(0, head)
    first = head
    second = dummy

    # 让first指针先走n步
    for _ in range(n):
        first = first.next

    # 同时移动first和second指针，直到first指针到达链表尾部
    while first:
        first = first.next
        second = second.next

    # 删除倒数第n个节点
    second.next = second.next.next

    return dummy.next

合并k个升序链表

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

def mergeKLists(lists):
    # 创建一个最小堆，用于存储每个链表的当前节点
    min_heap = []
    for i in range(len(lists)):
        if lists[i]:
            # 将每个链表的头节点加入最小堆中
            heapq.heappush(min_heap, (lists[i].val, i))
            lists[i] = lists[i].next

    # 创建一个哑节点作为结果链表的头节点
    dummy = ListNode(0)
    current = dummy

    # 从最小堆中取出最小的节点，将其添加到结果链表中
    while min_heap:
        val, index = heapq.heappop(min_heap)
        current.next = ListNode(val)
        current = current.next

        # 如果当前链表还有节点，将下一个节点加入最小堆中
        if lists[index]:
            heapq.heappush(min_heap, (lists[index].val, index))
            lists[index] = lists[index].next

    return dummy.next