282930313233343536373839404142434445464748495051525354555657585960616263

// Definition of Node
class ListNode {
    constructor(x) {
        this.val = x;
        this.next = null;
    }
}

class Solution {
    // Function to detect and remove cycle using Floyd’s algorithm
    detectAndRemoveCycle(head) {

        // Initialize slow and fast pointers
        let slow = head;
        let fast = head;

        // Step 1: Detect cycle
        while (fast !== null && fast.next !== null) {
            slow = slow.next;
            fast = fast.next.next;

            // If slow and fast meet, cycle exists
            if (slow === fast) {
                // Step 2: Find start of cycle
                slow = head;
                while (slow !== fast) {
                    slow = slow.next;
                    fast = fast.next;
                }

                // Step 3: Find last node of cycle and break it
                let ptr = slow;
                while (ptr.next !== slow) {
                    ptr = ptr.next;
                }
                ptr.next = null;
                return true;
            }
        }

        // If reached null, no cycle
        return false;
    }
}

// Driver function
function main() {
    // Create linked list with cycle
    let head = new ListNode(1);
    head.next = new ListNode(2);
    head.next.next = new ListNode(3);
    head.next.next.next = new ListNode(4);
    head.next.next.next.next = head.next; // Cycle

    let sol = new Solution();
    let ans = sol.detectAndRemoveCycle(head);

    if (ans) console.log("Cycle detected and removed");
    else console.log("No cycle found");
}

main();

Complexity Analysis

Time Complexity: O(N), we traverse the entire linked list. The fast pointer either reaches the end of the list or meets the slow pointer in linear time.
Space Complexity: O(1) , constant amount of extra space is used detect a cycle using Floyd's Cycle Detection Algorithm.