Doubly Linked List using Sentinel Nodes

// Each node contains the data,
// previous node pointer and
// the next node pointer
static class Node {
    int data;
     node next;
     node pre;
}

// To create a node, first define the node pointer
// and than assign the memory required by the node
// and return the pointer
Node createnode()
{
    Node node = new Node();
 retutn node; 
}

class Node {
    public $data;
    public $prev;
    public $next;

    public function __construct($data, $prev, $next) {
        $this->data = $data;
        $this->prev = $prev;
        $this->next = $next;
    }
}

class DoublyLinkedList {
    private $sentinel;

    public function __construct() {
        $this->sentinel = new Node(0, null, null);
        $this->sentinel->prev = $this->sentinel;
        $this->sentinel->next = $this->sentinel;
    }

    public function insertAtBeginning($data) {
        $newNode = new Node($data, $this->sentinel, $this->sentinel->next);
        $this->sentinel->next->prev = $newNode;
        $this->sentinel->next = $newNode;
        $this->updateSentinelData();
    }

    private function updateSentinelData() {
        // update sentinel data if needed
    }

    public function traverse() {
        $currentNode = $this->sentinel->next;
        while ($currentNode != $this->sentinel) {
            echo $currentNode->data . "\n";
            $currentNode = $currentNode->next;
        }
    }
}

$my_list = new DoublyLinkedList();
$my_list->insertAtBeginning(5);
$my_list->insertAtBeginning(10);
$my_list->insertAtBeginning(15);
$my_list->traverse();

class ListNode {
    int val;
    ListNode next;

    ListNode() {}

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

class LinkedList {
    ListNode head;
    ListNode tail;

    public LinkedList() {
        head = new ListNode();
        tail = new ListNode();
        head.next = tail;
    }

    public void insertAtPosition(int val, int pos) {
        ListNode newNode = new ListNode(val);
        ListNode currNode = head;
        for (int i = 0; i < pos; i++) {
            if (currNode.next == tail) {
                if (i == pos - 1) {
                    break;
                } else {
                    throw new IndexOutOfBoundsException("Position out of range");
                }
            }
            currNode = currNode.next;
        }
        newNode.next = currNode.next;
        currNode.next = newNode;
    }

    public void printList() {
        ListNode currNode = head.next;
        while (currNode != tail) {
            System.out.print(currNode.val + " -> ");
            currNode = currNode.next;
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList myLinkedList = new LinkedList();
        myLinkedList.insertAtPosition(1, 1);
        myLinkedList.insertAtPosition(3, 2);
        myLinkedList.insertAtPosition(2, 2);
        myLinkedList.printList();
    }
}

public class DoublyLinkedList {
    
    private Node head;
    private Node tail;
    private int size;
    
    private class Node {
        int data;
        Node prev;
        Node next;
        
        Node(int data) {
            this.data = data;
        }
    }
    
    // Constructor
    public DoublyLinkedList() {
        head = new Node(-1); // Sentinel node for head
        tail = new Node(-1); // Sentinel node for tail
        head.next = tail;
        tail.prev = head;
        size = 0;
    }
    
    // Method to insert a new node at the end of the doubly linked list
    public void insertAtEnd(int data) {
        Node newNode = new Node(data);
        Node prevNode = tail.prev;
        
        prevNode.next = newNode;
        newNode.prev = prevNode;
        newNode.next = tail;
        tail.prev = newNode;
        
        size++;
    }
    
    // Method to print the doubly linked list
    public void printList() {
        Node currentNode = head.next;
        while(currentNode != tail) {
            System.out.print(currentNode.data + " ");
            currentNode = currentNode.next;
        }
        System.out.println();
    }
    
    // Main method to demonstrate usage
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        
        list.insertAtEnd(1);
        list.insertAtEnd(2);
        list.insertAtEnd(3);
        list.insertAtEnd(4);
        list.insertAtEnd(5);
        
        list.printList(); // Output: 1 2 3 4 5
    }
}

class ListNode {
    int val;
    ListNode prev;
    ListNode next;
    
    public ListNode(int val) {
        this.val = val;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    ListNode head;
    ListNode tail;
    
    public DoublyLinkedList() {
        head = new ListNode(-1);
        tail = new ListNode(-1);
        head.next = tail;
        tail.prev = head;
    }
    
    public void insertFirstNode(int val) {
        ListNode newNode = new ListNode(val);
        newNode.next = head.next;
        head.next.prev = newNode;
        head.next = newNode;
        newNode.prev = head;
    }
    
    public void deleteFirstNode() {
        if (head.next == tail) {
            System.out.println("List is empty.");
            return;
        }
        ListNode firstNode = head.next;
        head.next = firstNode.next;
        firstNode.next.prev = head;
        firstNode.prev = null;
        firstNode.next = null;
        System.out.println("Deleted node with value " + firstNode.val);
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        list.insertFirstNode(3);
        list.insertFirstNode(2);
        list.insertFirstNode(1);
        System.out.println("Before deletion:");
        printList(list);
        list.deleteFirstNode();
        System.out.println("After deletion:");
        printList(list);
    }
    
    public static void printList(DoublyLinkedList list) {
        ListNode curr = list.head.next;
        while (curr != list.tail) {
            System.out.print(curr.val + " ");
            curr = curr.next;
        }
        System.out.println();
    }
}