链表中最长递增子列表

链表中最长递增子列表是指链表中连续的一段节点组成的子列表，满足节点值单调递增的条件，并且该子列表的长度是最长的。

解法

我们可以遍历一遍链表，同时维护两个变量：当前递增子列表的起始节点和结束节点，以及最长递增子列表的起始节点和结束节点。当遇到一个节点值不符合递增条件时，就可以更新当前递增子列表的起始节点和结束节点，重新开始计算递增子列表。如果当前递增子列表的长度大于最长递增子列表的长度，就更新最长递增子列表的起始节点和结束节点。

下面是 Python 代码实现：

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


def longest_increasing_sublist(head: ListNode) -> ListNode:
    if not head:
        return None

    longest_start = longest_end = curr_start = curr_end = head

    curr = head.next
    while curr:
        if curr.val > curr_end.val:
            curr_end = curr
        else:
            curr_start = curr_end = curr

        if curr_end.next and curr_end.next.val > curr_end.val:
            curr = curr_end.next
        else:
            if curr_end == longest_end:
                longest_start = curr_start
                longest_end = curr_end
            curr_start = curr_end = curr_end.next
            curr = curr_end

    return longest_start


# Example usage:
head = ListNode(1, ListNode(2, ListNode(3, ListNode(2, ListNode(4, ListNode(5, ListNode(1)))))))
longest = longest_increasing_sublist(head)
print(longest.val)  # Output: 2
print(longest.next.val)  # Output: 4
print(longest.next.next.val)  # Output: 5

时间复杂度

该算法的时间复杂度为 $O(n)$，其中 $n$ 是链表的长度。因为我们只需要遍历一遍链表即可找到最长递增子列表。

空间复杂度

该算法的空间复杂度为 $O(1)$，因为我们只需要维护几个指针。