@gobalkrishnan/dsa_collection/data_structure/linked_list/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){
            node.prev = new_node;
            new_node.next = node;
        }
        
        node = new_node;

        return node;
    }

    static insert_end(node,data){

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

        if(node==null){
           node = new_node;

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

            ptr.next = new_node;
            new_node.prev = ptr;

        }

        return node;
    }

    static insert_after(node, search_data, data){

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

        while(ptr.data!=search_data){
            ptr = ptr.next;
        }

        new_node.prev = ptr;
        new_node.next = ptr.next;
        ptr.next = new_node;
        ptr.next.prev = new_node;

        return node;
    }

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

        while(ptr.data!=search_data){
            ptr = ptr.next;
        }

        ptr.prev.next = new_node;
        new_node.prev = ptr.prev;
        new_node.next = ptr;
        ptr.prev = new_node;

        return node;
    }

    static delete_begin(node){

        var ptr = node;
        node = node.next;
        node.prev = null;
        ptr = null;

        return node;
    }

    static delete_end(node){

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

        ptr.prev.next = null;
        ptr = null;

        return node;
    }

    static delete_after(node,search_data){

        var ptr = node ;

        while(node.data!= search_data){
            ptr = ptr.next;
        }

        var temp = ptr.next;

        ptr.next = temp.next;
        temp.next.prev = ptr; 
        temp = null;

        return node;
    }

    static delete_before(node,search_data){
        var ptr = node; 
        while(ptr.data!=search_data){
            ptr = ptr.next;
        }
        var temp = ptr.prev;
        ptr.prev = temp.prev;
        temp.prev.next = ptr;
        return node;
    }

    // Display the list as a nested JSON format
    static display_as_json(node) {
        const cleanNode = (current) => {
            if (!current) return null; // Base case: no node to process
            return {
                data: current.data,
                next: cleanNode(current.next), // Recursively process `next`
                prev: current.prev ? { data: current.prev.data } : null, // Simplify `prev` to avoid circular references
            };
        };

        try {
            const nodeJson = cleanNode(node);
            console.log(JSON.stringify(nodeJson, null, 2)); // Log the JSON
            return nodeJson; // Return the JSON structure
        } catch (error) {
            console.error("Error converting to JSON:", error.message);
        }
        return node;
    }

    static display(node){
        var ptr = node;
        while(ptr!=null){
            process.stdout.write(`${ptr.data} ,`);

           ptr = ptr.next;
        }
        console.log('\n');
        return node;
    }

    static delete(node,search_data){
        var ptr = node;
        while(ptr.data!=search_data){
            ptr = ptr.next;
        }

        ptr.prev.next = ptr.next;
        ptr.next.prev = ptr.prev;
        ptr = null;

        return node;
    }

}