Added Doubly Linked List AST operations in Python + Linked List in Java

Author: SS56Bo

Java/data_structures/linked_lists/LL.java

@@ -0,0 +1,161 @@
+import java.util.Scanner;
+
+class Node {
+    int data;
+    Node next;
+    Node (int x) {
+        data = x;
+        next = null;
+    }
+}
+
+public class LL {
+    public static void printLL(Node head) {
+        Node current = head;
+        while (current!=null) {
+            System.out.print(current.data+" -> ");
+            current = current.next;
+        }
+        System.out.println("NULL");
+    }
+
+    public Node insertAtBeginning(Node head, int x) {
+        Node temp = new Node(x);
+        temp.next = head;
+        return temp;
+    }
+
+    public Node insertAtEnd(Node head, int x){
+        Node temp = new Node(x);
+        if (head == null) {
+            return temp;
+        }
+        Node current = head;
+        while (current.next != null) {
+            current = current.next;
+        }
+        current.next = temp;
+        return head;
+    }
+
+    public Node insertAtPosition(Node head, int data, int position) {
+        Node temp = new Node(data);
+        if (position == 1) {
+            temp.next = head;
+            return temp;
+        }
+
+        Node curr = head;
+        for (int i = 1; i<=position-2 && curr!=null; i++) {
+            curr=curr.next;
+        }
+        if (curr == null) {
+            return head;
+        }
+
+        temp.next = curr.next;
+        curr.next = temp;
+        return head;
+    }
+
+    public Node deleteHeadNode(Node head) {
+        if (head == null) {
+            return null;
+        } else {
+            return head.next;
+        }
+    } 
+
+    public Node deleteNodeAtEnd(Node head) {
+        if (head == null) return null;
+        if (head.next == null) return null;
+
+        Node curr = head;
+        while (curr.next.next!=null) {
+            curr = curr.next;
+        }
+        curr.next = null;
+        return head;
+    }
+
+    public Node deleteNodeAnyPosition(Node head, int position) {
+        if (head==null) return null;
+        if (position==1) return head.next;
+
+        Node curr = head;
+        for (int i=1; i<=position-2 && curr!=null; i++) {
+            curr = curr.next;
+        }
+
+        if (curr == null || curr.next == null) {
+            return head;
+        }
+
+        curr.next = curr.next.next;
+        return head;
+    }
+
+    public static void main(String[] args) {
+        
+        Scanner sc = new Scanner(System.in);
+
+        LL list = new LL();
+        Node head = null;
+        int choice = 0;
+
+        while (choice!=8) {
+            System.out.println("\n");
+            System.out.println("Choose what to do?");
+            System.out.println("1. Insert Node at the beginning");
+            System.out.println("2. Insert Node at the end");
+            System.out.println("3. Insert Node at any position");
+            System.out.println("4. Delete Node at the beginning");
+            System.out.println("5. Delete Node at the end");
+            System.out.println("6. Delete Node at any position");
+            System.out.println("7. Print the Linked List");
+            System.out.print("Enter your choice: ");
+            choice = sc.nextInt();
+
+            switch (choice) {
+                case 1: // Insert at beginning
+                    System.out.print("Enter value: ");
+                    int val1 = sc.nextInt();
+                    head = list.insertAtBeginning(head, val1);
+                    break;
+                case 2: // Insert at any end
+                    System.out.print("Enter value: ");
+                    val1 = sc.nextInt();
+                    head = list.insertAtEnd(head, val1);
+                    break;
+                case 3: // Insert at any position
+                    System.out.print("Enter value: ");
+                    val1 = sc.nextInt();
+                    System.out.print("Enter position: ");
+                    int pos = sc.nextInt();
+                    head = list.insertAtPosition(head, val1, pos);
+                    break;
+                case 4: // Delete at the beginning
+                    head = list.deleteHeadNode(head);
+                    System.out.println("Node deleted at beginning!");
+                    break;
+                case 5: // Delete at the end
+                    head = list.deleteNodeAtEnd(head);
+                    System.out.println("Node deleted at end!");
+                    break;
+                case 6: // Delete at any position
+                    System.out.print("Enter position: ");
+                    pos = sc.nextInt();
+                    head = list.deleteNodeAnyPosition(head, pos);
+                    System.out.println("Node deleted at position "+pos);
+                    break;
+                case 7: // Print List
+                    System.out.println("\n");
+                    LL.printLL(head);
+                    System.out.println("\n");
+                    break;
+            }
+        }
+
+        sc.close();
+    }
+}

Python/data_structures/linked_lists/doubly_LL.py

@@ -0,0 +1,139 @@
+# Doubly Linked List implementation
+class Node:
+    def __init__(self, values):
+        self.data = values
+        self.previous = None
+        self.next = None
+
+def insert_at_beginning(head, x):
+    node = Node(x)
+    node.next = head
+    if head:
+        head.previous = node
+    return node
+
+def insert_at_end(head, x):
+    node = Node(x)
+    if head is None:
+        return node
+    temp = head
+    while temp.next:
+        temp = temp.next 
+    temp.next = node
+    node.previous = temp
+    return head
+
+def insert_after_node(node, x):
+    if node is None:
+        print("Node cannot be null")
+        return
+    a = Node(x)
+    a.next = node.next 
+    a.previous = node
+    if node.next:
+        node.next.previous = a
+    node.next = a
+
+def insert_before_node(head, node, val):
+    if node is None:
+        print("Node cannot be null")
+        return head
+    
+    new = Node(val)
+    new.previous = node.previous
+    new.next = node 
+    if node.previous:                 # if not the head
+        node.previous.next = new
+    else:                             # if it was the head, new becomes the head
+        head = new
+    node.previous = new
+    return head
+
+def delete_head(head):
+    if head is None:
+        return None
+    if head.next is None:  # only one element
+        return None
+    new_head = head.next
+    new_head.previous = None
+    return new_head
+
+def delete_at_end(head):
+    if head is None:
+        return None
+    if head.next is None:  # only one element
+        return None
+    temp = head
+    while temp.next:
+        temp = temp.next
+    temp.previous.next = None
+    return head
+
+def delete_by_value(head, val):
+    if head is None:
+        return None
+    temp = head
+
+    # if head itself needs to be deleted
+    if temp.data == val:
+        return delete_head(head)
+    
+    while temp and temp.data != val:
+        temp = temp.next
+
+    if temp is None:
+        print(f"Value {val} not found in the list.")
+        return head
+
+    if temp.next:  
+        temp.next.previous = temp.previous
+    if temp.previous:
+        temp.previous.next = temp.next
+    return head
+
+def print_LL(head):
+    temp = head
+    while temp:
+        print(temp.data, end=" <-> ")
+        temp = temp.next
+    print("None")
+
+# print the doubly linked list backwards
+def print_reverse(head):
+    if head is None:
+        print("None")
+        return
+ 
+    temp = head
+    while temp.next:
+        temp = temp.next
+
+    # print backwards
+    while temp:
+        print(temp.data, end=" <-> ")
+        temp = temp.previous
+    print("None")
+
+
+if __name__ == '__main__':
+    head = None
+    head = insert_at_beginning(head, 89)       
+    head = insert_at_beginning(head, 63)       
+    insert_after_node(head.next, 56)      
+    head = insert_before_node(head, head.next, 10)  
+    head = insert_at_end(head, 96)  
+    head = insert_at_beginning(head, 22)    
+    head = insert_at_end(head, 32)  
+    print_LL(head)
+    head = delete_head(head) 
+    head = delete_head(head) 
+    head = delete_head(head)   
+    print_LL(head)
+    head = insert_at_end(head, 88)  
+    head = insert_at_end(head, 44)  
+    print_LL(head)
+    head = delete_at_end(head)
+    print_LL(head)
+    head = delete_by_value(head, 32)
+    print_LL(head)
+    print_reverse(head)