LeetCode题解 - LinkedList | 探索链表数据结构的奥秘

2023-11-10 17:34:44

链表：算法和数据结构中的基本工具

链表是一种简单但强大的数据结构，在算法和数据结构中扮演着至关重要的角色。它由一系列称为节点的元素组成，每个节点包含一个数据项和指向下一个节点的指针。这种灵活性使得链表非常适合处理动态数据，因为可以轻松地插入、删除和修改元素。

链表操作：插入、删除、查找和修改

在链表中进行这些操作至关重要：

插入： 将元素添加到链表的头部、尾部或指定位置。
删除： 从链表的头部、尾部或指定位置删除元素。
查找： 在链表中搜索特定元素。
修改： 修改链表中元素的数据项。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert_at_head(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def insert_at_tail(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current_node = self.head
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node

    def insert_at_index(self, index, data):
        new_node = Node(data)
        if index == 0:
            self.insert_at_head(data)
        else:
            current_node = self.head
            for i in range(index - 1):
                current_node = current_node.next
            new_node.next = current_node.next
            current_node.next = new_node

    def delete_at_head(self):
        if self.head is None:
            return
        self.head = self.head.next

    def delete_at_tail(self):
        if self.head is None:
            return
        current_node = self.head
        while current_node.next.next is not None:
            current_node = current_node.next
        current_node.next = None

    def delete_at_index(self, index):
        if index == 0:
            self.delete_at_head()
        else:
            current_node = self.head
            for i in range(index - 1):
                current_node = current_node.next
            current_node.next = current_node.next.next

    def find(self, data):
        current_node = self.head
        while current_node is not None:
            if current_node.data == data:
                return current_node
            current_node = current_node.next
        return None

    def modify(self, index, data):
        if index == 0:
            self.head.data = data
        else:
            current_node = self.head
            for i in range(index):
                current_node = current_node.next
            current_node.data = data

    def print_list(self):
        current_node = self.head
        while current_node is not None:
            print(current_node.data, end=" ")
            current_node = current_node.next

链表遍历：从头到尾

遍历链表涉及从链表的头部开始，依次访问每个节点，直到到达尾部。这对于获取链表中所有元素或执行其他操作非常有用。

def traverse_list(head):
    current_node = head
    while current_node is not None:
        print(current_node.data)
        current_node = current_node.next

链表排序：快速有效

链表排序需要将链表中的元素按一定顺序排列。常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序和快速排序。

def sort_list(head):
    if head is None or head.next is None:
        return head

    current_node = head
    previous_node = None

    while current_node is not None:
        next_node = current_node.next
        if previous_node is None or current_node.data >= previous_node.data:
            previous_node = current_node
        else:
            current_node.next = previous_node
            previous_node = current_node
        current_node = next_node

    return previous_node

链表反转：颠倒乾坤

链表反转将链表中的元素顺序颠倒。从尾部开始，将每个节点移动到链表的头部，直到完成。

def reverse_list(head):
    previous_node = None
    current_node = head

    while current_node is not None:
        next_node = current_node.next
        current_node.next = previous_node
        previous_node = current_node
        current_node = next_node

    return previous_node

链表循环：环状结构

循环链表是指链表中某个节点指向之前访问过的节点，形成一个闭合环路。检测循环链表非常重要，因为它可以帮助解决链表中的错误或异常。

def detect_cycle(head):
    slow_ptr = head
    fast_ptr = head

    while slow_ptr is not None and fast_ptr is not None and fast_ptr.next is not None:
        slow_ptr = slow_ptr.next
        fast_ptr = fast_ptr.next.next

        if slow_ptr == fast_ptr:
            return True

    return False

链表合并：两个合一

链表合并将两个有序链表合并成一个新的有序链表。合并后的链表依然保持有序性。

def merge_lists(l1, l2):
    dummy_head = Node(None)
    current_node = dummy_head

    while l1 is not None and l2 is not None:
        if l1.data < l2.data:
            current_node.next = l1
            l1 = l1.next
        else:
            current_node.next = l2
            l2 = l2.next
        current_node = current_node.next

    while l1 is not None:
        current_node.next = l1
        l1 = l1.next
        current_node = current_node.next

    while l2 is not None:
        current_node.next = l2
        l2 = l2.next
        current_node = current_node.next

    return dummy_head.next

链表交叉：殊途同归

链表交叉是指在两个链表中存在一个公共节点，即两个链表在某个位置开始共享相同的节点。检测链表交叉可以帮助解决两个链表之间是否存在交集的问题。

def detect_intersection(l1, l2):
    len1 = get_length(l1)
    len2 = get_length(l2)

    if len1 > len2:
        l1 = skip_nodes(l1, len1 - len2)
    elif len2 > len1:
        l2 = skip_nodes(l2, len2 - len1)

    while l1 is not None and l2 is not None:
        if l1 == l2:
            return l1
        l1 = l1.next
        l2 = l2.next

    return None

def get_length(head):
    count = 0
    while head is not None:
        count += 1
        head = head.next
    return count

def skip_nodes(head, n):
    while n > 0:
        head = head.next
        n -= 1
    return head