Introduction

In this blog post, we will explore how to solve the LeetCode problem "2487" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given the head of a linked list. Remove every node which has a node with a greater value anywhere to the right side of it. Return the head of the modified linked list. Example 1: Input: head = [5,2,13,3,8] Output: [13,8] Explanation: The nodes that should be removed are 5, 2 and 3. - Node 13 is to the right of node 5. - Node 13 is to the right of node 2. - Node 8 is to the right of node 3. Example 2: Input: head = [1,1,1,1] Output: [1,1,1,1] Explanation: Every node has value 1, so no nodes are removed. Constraints: The number of the nodes in the given list is in the range [1, 105]. 1 <= Node.val <= 105

Explanation

Here's the breakdown of the solution:

• Reverse the Linked List: Reversing the list allows us to traverse from the tail to the head, making it easy to identify and remove nodes that have a larger value to their right (now, left).
• Iterate and Remove: Iterate through the reversed list, keeping track of the maximum value encountered so far. If a node's value is less than the maximum, remove it.

• Reverse Back: Reverse the modified list to restore the original order.

• Time Complexity: O(n), where n is the number of nodes in the linked list.

• Space Complexity: O(1)

Code

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

def solve():
    def reverseList(head):
        prev = None
        curr = head
        while curr:
            next_node = curr.next
            curr.next = prev
            prev = curr
            curr = next_node
        return prev

    def removeNodes(head):
        head = reverseList(head)
        curr = head
        max_val = curr.val
        prev = None

        while curr:
            if curr.val < max_val:
                if prev:
                    prev.next = curr.next
                curr = curr.next
            else:
                max_val = curr.val
                if prev is None:
                    head = curr
                prev = curr
                curr = curr.next

        return reverseList(head)

    return removeNodes