Added Linked List without maintaining a tail

Author: mohanakrishnavh

DataStructures/LinkedList.py

@@ -0,0 +1,179 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.head = None
+
+    def insert(self, data: int, index=None) -> None:
+        """
+        Inserting a new element to the Linked List
+        :param data: Data of the new element
+        :param index: Index to insert
+        :return: None
+
+        Time Complexity: O(n)
+        """
+
+        is_valid_index = isinstance(index, int)
+
+        if is_valid_index and index >= 0:
+            self._insert_at_index(data, index)
+        else:
+            self._insert_at_tail(data)
+
+    def _insert_at_index(self, data: int, index: int) -> None:
+        # If the list is empty
+        if self.head is None:
+            self.head = Node(data)
+            return
+
+        # If the user wants to insert at the first position
+        if index == 0:
+            self._insert_at_head(data)
+        else:
+            new_node = Node(data)
+            current_node = self.head
+            previous_node = self.head
+
+            for i in range(index-1):
+                # If the user has provided an index greater than the size of the list
+                if current_node is None:
+                    previous_node.next = new_node
+                    return
+
+                previous_node = current_node
+                current_node = current_node.next
+
+            new_node.next = current_node.next
+            previous_node = current_node
+            previous_node.next = new_node
+
+    def _insert_at_tail(self, data: int) -> None:
+        """
+        Inserting an element at the end of the Linked List
+        :param data: Data of the new node
+        :return: None
+
+        Time Complexity: O(n)
+        """
+        new_node = Node(data)
+        current_node = self.head
+
+        # If there are no elements in the linked list
+        if self.head is None:
+            self.head = new_node
+            return
+
+        # Traversing the elements of the list to find the last element
+        while current_node.next is not None:
+            current_node = current_node.next
+
+        current_node.next = new_node
+
+    def _insert_at_head(self, data) -> None:
+        """
+        Inserts a new node at the head of the Linked List
+        :param data: Data of the new node
+        :return: None
+
+        Time Complexity: O(1)
+        """
+        new_node = Node(data)
+        prev_head = self.head
+
+        # Make the new node the head of the linked list and add link to old head
+        new_node.next = prev_head
+        self.head = new_node
+
+    def delete(self, index=None) -> None:
+        """
+        Delete an element from the Linked List
+        :param index: Index of the element to delete
+        :return: None
+
+        Time Complexity: O(n)
+        """
+        # If the list is empty, do not do anything
+        if self.head is None:
+            return
+
+        is_valid_index = isinstance(index, int)
+
+        if is_valid_index and index >= 0:
+            self._delete_from_index(index)
+        else:
+            self._delete_from_tail()
+
+    def _delete_from_head(self) -> None:
+        """
+        Delete an element from the head of the Linked List
+        :return: None
+
+        Time Complexity: O(1)
+        """
+        new_head = self.head.next
+        self.head = new_head
+
+    def _delete_from_tail(self) -> None:
+        """
+        Delete an element from the tail of the Linked List
+        :return: None
+
+        Time Complexity: O(n)
+        """
+        current_node = self.head
+        previous_node = None
+
+        while current_node.next is not None:
+            previous_node = current_node
+            current_node = current_node.next
+
+        previous_node.next = None
+
+    def _delete_from_index(self, index: int) -> None:
+        """
+        Delete an element from the the specified index of the Linked List
+        :return: None
+
+        Time Complexity: O(n)
+        """
+        if index == 0:
+            self._delete_from_head()
+        else:
+            current_node = self.head
+            previous_node = None
+
+            for i in range(index):
+                # If the user has provided an index greater than the size of the list
+                if current_node.next is None:
+                    previous_node.next = None
+                    return
+
+                previous_node = current_node
+                current_node = current_node.next
+
+            previous_node.next = current_node.next
+            current_node.next = None
+
+    def print_list(self) -> None:
+        """
+        Prints the elements in the list
+
+        Time Complexity: O(n)
+        :return: None
+        """
+        current_node = self.head
+        while current_node.next is not None:
+            print(current_node.data, end=" -> ")
+            current_node = current_node.next
+        print(current_node.data)
+
+
+
+
+
+

DataStructures/LinkedList/LinkedList.py

@@ -0,0 +1,32 @@
+from DataStructures.LinkedList.LinkedList import LinkedList
+
+linked_list = LinkedList()
+linked_list2 = LinkedList()
+
+# Inserting elements to the linked list
+linked_list.insert(0, 1)  # linked_list.insert(data, index)
+linked_list.insert(10)
+linked_list.insert(20, 1000)
+linked_list.insert(30)
+linked_list.insert(5, 0)
+linked_list.insert(15, 2)
+linked_list.insert(40, 5000)
+linked_list.print_list()
+
+# Inserting and Removing elements from the linked list
+linked_list2.delete()
+linked_list2.delete(-1000)
+linked_list2.delete(10)
+linked_list2.insert(0, 1)  # linked_list.insert(data, index)
+linked_list2.insert(1, 1)
+linked_list2.insert(2, 100)
+linked_list2.insert(3)
+linked_list2.insert(4)
+linked_list2.insert(5)
+linked_list2.print_list()
+linked_list2.delete(3)
+linked_list2.print_list()
+linked_list2.delete(100)  # linked_list.delete(index)
+linked_list2.print_list()
+linked_list2.delete(0)
+linked_list2.print_list()