挑战力扣算法题，高效掌握数据结构与算法！

2023-09-05 05:37:00

一、反转链表

反转链表是一种经典的数据结构问题，需要将链表中节点的顺序逆序排列。力扣算法题中的反转链表问题要求我们在不改变节点值的前提下，将链表反转。

def reverse_list(head):
    """
    反转链表

    :param head: 链表的头节点
    :return: 反转后的链表的头节点
    """

    prev = None
    current = head

    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node

    return prev

二、链表相交

链表相交问题需要找出两个链表的相交节点，如果不存在相交节点则返回 null。力扣算法题中的链表相交问题要求我们找到两个链表的第一个公共节点。

def get_intersection_node(headA, headB):
    """
    找出两个链表的相交节点

    :param headA: 第一个链表的头节点
    :param headB: 第二个链表的头节点
    :return: 相交节点
    """

    # 计算两个链表的长度
    len_a = 0
    len_b = 0
    current_a = headA
    current_b = headB
    while current_a:
        len_a += 1
        current_a = current_a.next
    while current_b:
        len_b += 1
        current_b = current_b.next

    # 让较长链表先走差值步数
    if len_a > len_b:
        for _ in range(len_a - len_b):
            headA = headA.next
    else:
        for _ in range(len_b - len_a):
            headB = headB.next

    # 然后两个链表同时遍历，直到找到相交节点
    while headA and headB:
        if headA == headB:
            return headA
        headA = headA.next
        headB = headB.next

    return None

三、旋转链表

旋转链表问题需要将链表向右旋转 k 个位置，其中 k 是一个正整数。力扣算法题中的旋转链表问题要求我们返回旋转后的链表的头节点。

def rotate_list(head, k):
    """
    将链表向右旋转 k 个位置

    :param head: 链表的头节点
    :param k: 旋转的步数
    :return: 旋转后的链表的头节点
    """

    # 计算链表的长度
    len = 0
    current = head
    while current:
        len += 1
        current = current.next

    # 计算旋转后的链表的尾节点
    k %= len
    tail = head
    for _ in range(len - k - 1):
        tail = tail.next

    # 将链表断开并重新连接
    new_head = tail.next
    tail.next = None
    current = new_head
    while current.next:
        current = current.next
    current.next = head

    return new_head

四、数据流中的第 K 大元素

数据流中的第 K 大元素问题需要在一个数据流中找到第 K 大的元素。力扣算法题中的数据流中的第 K 大元素问题要求我们实现一个数据结构，支持以下两个操作：

add(val)：将一个元素添加到数据结构中
findKthLargest()：返回数据结构中第 K 大的元素

class KthLargest:

    def __init__(self, k: int):
        """
        初始化数据结构
        """
        self.k = k
        self.nums = []

    def add(self, val: int) -> None:
        """
        将一个元素添加到数据结构中
        """
        self.nums.append(val)
        self.nums.sort()
        if len(self.nums) > self.k:
            self.nums.pop(0)

    def findKthLargest(self) -> int:
        """
        返回数据结构中第 K 大的元素
        """
        return self.nums[self.k - 1]

五、翻转二叉树

翻转二叉树问题需要将一棵二叉树的左右子树互换。力扣算法题中的翻转二叉树问题要求我们返回翻转后的二叉树。

def invert_tree(root):
    """
    翻转二叉树

    :param root: 二叉树的根节点
    :return: 翻转后的二叉树的根节点
    """

    if not root:
        return None

    left = invert_tree(root.left)
    right = invert_tree(root.right)

    root.left = right
    root.right = left

    return root