@gobalkrishnan/dsa_collection/data_structure/linked_list/circular_doubly_linked_list.js

Data Structure and Algorthim used to build application

import { Node } from "../../node/doubly_node.js";

export class LinkedList{
   constructor(){}
   
   static insert_begin(node,data){

    var new_node = new Node({data:data,prev:null,next:null});

    if(node==null){
        new_node.prev = new_node;
        new_node.next = new_node;
        node = new_node;
    }else{
        var ptr = node;
        while(ptr.next != node){
            ptr = ptr.next;
        }

        
        new_node.prev = ptr;
        new_node.next = ptr.next;
        ptr.next.prev = new_node;
        ptr.next = new_node;
        node = ptr.next;
    
    }
    return node;
   };

   static insert_end(node,data){
    
    var new_node = new Node({data:data,prev:null,next:null});

    
    if(node==null){
        new_node.prev = new_node;
        new_node.next = new_node;
        node = new_node;
    }else{
        var ptr = node;
        while(ptr.next != node){
            ptr = ptr.next;
        }

        new_node.prev = ptr;
        new_node.next = ptr.next;
        node.prev = new_node;
        ptr.next = new_node;
    }

    return node;
   }

   static delete_begin(node){
    var ptr = node;
    while(ptr.next != node){
        ptr = ptr.next;
    }

    var temp = ptr.next;
    ptr.next = temp.next;
    temp.next.prev = ptr;
    temp = null;
    node = ptr.next;
    return node; 
   }

   static delete_end(node){

    var ptr = node;
    while(ptr.next != node){
        ptr = ptr.next;
    }
     
    ptr.prev.next = node;
    node.prev = ptr.prev;


    return node;
   }

   static display_as_json(node){
    const cleanNode = (current, head, visited = new Set()) => {
        if (!current) return null; // Base case: no node to process
        if (visited.has(current)) return { data: current.data }; // Stop recursion on circular reference
    
        // Mark the current node as visited
        visited.add(current);
    
        return {
            data: current.data,
            next: cleanNode(current.next, head, visited), // Recursively process `next`
            prev: current.prev ? { data: current.prev.data } : null, // Simplify `prev` to avoid circular references
        };
    };
    
    // Example Usage
    try {
        const nodeJson = cleanNode(node, node); // Pass the head node to detect circularity
        console.log(JSON.stringify(nodeJson, null, 2)); // Log the JSON
    } catch (error) {
        console.error("Error converting to JSON:", error.message);
    }

    return node; 
     
   }


   static display = (node) => {
    var ptr = node;
    while (ptr.next != node) {
        process.stdout.write(`${ptr.data} ,`);
        ptr = ptr.next; // Print the data in the same line
    }
    process.stdout.write(`${ptr.data} ,`);
    console.log("\n");
    return node;
}


}