Scratch Readable Implementation in Python

Author: sushant097

.gitignore

@@ -0,0 +1 @@
+Tree/notes/*.DOCX

LinkedList/CircularSinglyLinkedList.py

@@ -0,0 +1,165 @@
+
+
+class Node:
+    def __init__(self, value=None) -> None:
+        self.value = value
+        self.next = None
+
+
+class CircularSinglyLinkedList:
+    def __init__(self) -> None:
+        self.head = None
+        self.tail = None
+
+    def __iter__(self):
+        node = self.head
+        while node:
+            yield node
+            if node.next == self.head:
+                break
+            node = node.next
+    
+    # Creation of circular singly linked list
+    def createCSLL(self, value):
+        node = Node(value)
+        node.next = node
+        self.head = node
+        self.tail = node
+
+    # Insertion in circular singly linked list
+    def insertInCSLL(self, value, location):
+        if self.head is None:
+            return
+        else:
+            newNode = Node(value)
+            # Insert at first -> TIme: O(1); Space: O(1)
+            # 1. Update newNode.next = head
+            # 2. Update lastNode.next -> newNode
+            # 3. Update tail to newNode
+            if location == 0:
+                newNode.next = self.head
+                self.head = newNode
+                lastNode = self.tail
+                lastNode.next = newNode
+
+            # Insert into last -> Time: O(1); Space: O(1)
+            # 1. Update last node next = newNode
+            # 2. Update newNode.next = reference to first node
+            # 3. Update tail to newNode
+            elif location == -1:
+                prevNode = self.tail
+                prevNode.next = newNode
+                newNode.next = self.head
+                self.tail = newNode
+            
+            else:
+                # Insert into kth location -> Time: O(n); Space: O(1)
+                # 1. Traverse to k-1 node
+                # 2. Update newNode next to k-1 node.next
+                # 3. Update k-1 node.next to newNode
+
+                # 1. Traverse to k-1 node; where k is the position to insert newNode
+                tempNode = self.head
+                index = 0
+                while index < location - 1:
+                    tempNode = tempNode.next
+                    index += 1
+                # 2. Update newNode next to k-1 node.next
+                newNode.next = tempNode.next
+                # 3. Update k-1 node.next to newNode
+                tempNode.next = newNode
+
+    # Time: O(n)
+    def traversalCLL(self):
+        if self.head is None:
+            print("No any node to traverse")
+        else:
+            tempNode = self.head
+            while tempNode:
+                print(tempNode.value)
+                tempNode = tempNode.next
+                if tempNode == self.tail.next:
+                    break
+    
+    # Searching for a node in circular singly linked list
+    def searchCSLL(self, value):
+        if self.head is None:
+            print("No any node to search.")
+        else:
+            tempNode = self.head
+            while tempNode:
+                if tempNode.value == value:
+                    return tempNode.value
+                tempNode = tempNode.next
+                if tempNode == self.tail.next:
+                    return "The node does not exist!"
+    
+    # Delete in circular singly linked list
+    def deleteNode(self, location):
+        if self.head is None:
+            print('No any node exists to delete!')
+        else:
+            if location == 0:
+                if self.head == self.tail:
+                    self.head = None
+                    self.tail = None
+                    self.head.next = None
+                else:
+                    # If more than one element
+                    # Make head ref to next node
+                    # Then, make last node ref to second node
+                    # Finally, garbage collector delete first node
+                    self.head = self.head.next
+                    self.tail.next = self.head
+            elif location == -1:
+                if self.head == self.tail:
+                    self.head = None
+                    self.tail = None
+                    self.head.next = None
+                else:
+                    tempNode = self.head
+                    while tempNode:
+                        if tempNode.next == self.tail:
+                            break
+                        tempNode = tempNode.next
+                    tempNode.next = self.head
+                    self.tail = tempNode
+            else:
+                tempNode = self.head
+                index = 0
+                while index < location - 1:
+                    tempNode = tempNode.next
+                    index += 1
+                delNode = tempNode.next
+                tempNode.next = delNode.next
+
+    # Delete entire circular singly linked list
+    # Make 3 reference to null 
+    def deleteEntireCLL(self):
+        self.head = None
+        self.tail.next = None
+        self.tail = None
+
+circularSLL = CircularSinglyLinkedList()
+circularSLL.createCSLL(-1)
+
+circularSLL.insertInCSLL(0, 0)
+circularSLL.insertInCSLL(1, 0)
+circularSLL.insertInCSLL(2, 0)
+
+circularSLL.insertInCSLL(10, -1)
+circularSLL.insertInCSLL(15, -1)
+
+circularSLL.insertInCSLL(20, 3)
+circularSLL.insertInCSLL(25, 4)
+print([node.value for node in circularSLL])
+# circularSLL.traversalCLL()
+# print(circularSLL.searchCSLL(2))
+# print(circularSLL.searchCSLL(4))
+circularSLL.deleteNode(0)
+circularSLL.deleteNode(-1)
+circularSLL.deleteNode(2)
+print([node.value for node in circularSLL])
+
+circularSLL.deleteEntireCLL()
+print([node.value for node in circularSLL])

LinkedList/DoublyLinkedList.py

@@ -0,0 +1,197 @@
+
+from sqlalchemy import null
+
+
+class Node:
+    def __init__(self, value=None) -> None:
+        self.value = value
+        self.next = None
+        self.prev = None
+    
+class DoublyLinkedList:
+    def __init__(self) -> None:
+        self.head = None
+        self.tail = None
+    
+    def __iter__(self):
+        node = self.head
+        while node:
+            yield node
+            node = node.next
+    
+    # Creation of doubly linkedlist
+    def createDoublyLL(self, value):
+        newNode = Node(value)
+        newNode.prev = None
+        newNode.next = None
+        self.head = newNode
+        self.tail = newNode
+        return "Creation of Doubly Linked List successful."
+    
+    # Insertion in Doubly Linked List
+    def insertInDoublyLL(self, value, location):
+        if self.head is None:
+            print("First create a Doubly Linked List, called createDoublyLL() method.")
+            return
+        newNode = Node(value)
+        if location == 0: # Time: O(1); Space: O(1)
+            # insert at the beginning
+            # 1. Create a newNode
+            # 2. Make newNode prev ref to Null
+            # 3. Make newNode.next to FirstNode
+            # 4. Update FistNode.prev ref to newNode
+            # 5. Update head ref to newNode.
+            newNode.prev = None
+            newNode.next = self.head
+            self.head.prev = newNode
+            self.head = newNode
+
+        
+        elif location == -1: # Time: O(1); Space: O(1)
+            # Insert newNode at last of DoublyLL
+            # 1. Create a newNode with a given value.
+            # 2. Make newNode.next to null
+            # 3. Make newNode.prev to lastNode
+            # 4. Update lastNode.next to newNode
+            # 5. Update tail to newNode
+            newNode.next = None
+            newNode.prev = self.tail
+            self.tail.next = newNode
+            self.tail = newNode
+        
+        else:
+            # Insert newNode at specified location -> Time: O(n); Space: O(1)
+            # 1. Creation of newNOde
+            # 2. Traverse DoubleLL until index < location -1
+            # 3. Make newNode.next = prevNode.next
+            # 4. Update prevNode.next to newNode
+            # 5. Update nextNode.prev = newNode
+            # 6. Make newNode.prev = prevNode
+            tempNode = self.head
+            index = 0
+            while index < location - 1:
+                tempNode = tempNode.next
+                index += 1
+            nextNode = tempNode.next
+            newNode.next = nextNode
+            tempNode.next = newNode
+            newNode.prev = tempNode
+            nextNode.prev = newNode
+            
+    # Traversal Method in DoublyLL -> Time: O(n); Space: O(1)
+    def traverseDoublyLL(self):
+        if self.head is None:
+            print("There is not any element to traverse")
+        else:
+            tempNode = self.head
+            while tempNode:
+                print(tempNode.value)
+                tempNode = tempNode.next
+
+    # Reverse Traversal Method in Doubly Linked List -> Time: O(n); Space: O(1)
+    def reverseTraverseDoublyLL(self):
+        if self.head is None:
+            print("There is not any element to traverse.")
+        else:
+            tempNode = self.tail
+            while tempNode:
+                print(tempNode.value)
+                tempNode = tempNode.prev
+    
+    # Search Method in Doubly Linked List -> Time: O(n); Space: O(1)
+    def searchElementDLL(self, value):
+        if self.head is None:
+            return "There is not any element in the Linked List to search."
+        else:
+            tempNode = self.head
+            while tempNode:
+                if tempNode.value == value:
+                    return tempNode.value
+                tempNode = tempNode.next
+            return "The node value does not exist in the linked list"
+
+    # Deletion of node in Doubly Linked List
+    def deleteElementDLL(self, location): # Time: O(n); Space: O(1)
+        if self.head is None:
+            return "No any node to delete in List."
+        else:
+            # Delete at the beginning of list -> Time: O(1); Space: O(1)
+            if location == 0:
+                # Case 1: if there is only one node
+                # Update head and tail ref to null
+                if self.head == self.tail:
+                    self.head, self.tail = None, None
+                else:
+                    # Case 2: more than one node 
+                        # 1. Update head to second node
+                        # 2. Updare secondNode.prev to null
+                    self.head = self.head.next
+                    self.head.prev = None
+            
+            # Delete from the last of List -> Time: O(1); Space: O(1)
+            elif location == -1:
+                # Case 1: If there is only one element
+                # Update head and tail ref to null
+                if self.head == self.tail:
+                    self.head, self.tail = None, None
+                else:
+                    # Case 2: more than one node
+                        # 1. Update prevNode.next to null
+                        # 2. Update tail to prevNode
+                    prevNode = self.tail.prev
+                    prevNode.next = None
+                    self.tail = prevNode
+            
+            # Delete from the given location -> Time: O(n); Space: O(1)
+            else:
+                # 1. Traverse untill before given location
+                # Update prevNode.next to nextNode
+                # Update nextNode.prev to prevNode
+                tempNode = self.head
+                index = 0
+                while index < location - 1:
+                    tempNode = tempNode.next
+                    index += 1
+                
+                delNode = tempNode.next
+                nextNode = delNode.next
+                tempNode.next = nextNode
+                nextNode.prev = tempNode
+
+    # Delete Entire Double Linked List
+    def deleteEntireDoubleLL(self):  # -> Time: O(n); Space: O(1)
+        # Steps:
+        # 1. Traverse through list and make all node prev to null
+        # 2. Finally Update head and tail ref to null
+        # 3. By that Garbage collector delete the entire list where there is no
+        #    connection in both ways
+        node = self.head
+        while node:
+            node.prev = None
+            node = node.next
+        self.head = None
+        self.tail = None
+
+doublyLL = DoublyLinkedList()
+doublyLL.createDoublyLL(1)
+
+doublyLL.insertInDoublyLL(2, 0)
+doublyLL.insertInDoublyLL(5, -1)
+doublyLL.insertInDoublyLL(7, 1)
+doublyLL.insertInDoublyLL(4, -1)
+doublyLL.insertInDoublyLL(8, 2)
+print([node.value for node in doublyLL])
+# doublyLL.traverseDoublyLL()
+# print("#######################")
+# doublyLL.reverseTraverseDoublyLL()
+# print("###########################")
+# print(doublyLL.searchElementDLL(5))
+doublyLL.deleteElementDLL(0)
+doublyLL.deleteElementDLL(-1)
+doublyLL.deleteElementDLL(2)
+print([node.value for node in doublyLL])
+
+doublyLL.deleteEntireDoubleLL()
+print([node.value for node in doublyLL])
+
+

LinkedList/LinkedList.py

@@ -0,0 +1,135 @@
+
+
+class Node:
+    def __init__(self, value=None) -> None:
+        self.value = value
+        self.next = None
+
+
+class SLinkedList:
+    def __init__(self) -> None:
+        self.head = None
+        self.tail = None
+
+    def __iter__(self):
+        node = self.head
+        while node:
+            yield node
+            node = node.next
+
+    def __str__(self) -> str:
+        values = [str(x.value) for x in self]
+        return ' -> '.join(values)
+    
+    def __len__(self):
+        result = 0
+        node = self.head
+        while node:
+            result += 1
+            node = node.next
+        return result
+    
+    # insert in Linked List
+    def insert_element(self, value, location):
+        newNode = Node(value)
+        if self.head is None:
+            self.head = newNode
+            self.tail = newNode
+        else:
+            # insert at first : Time: O(1)
+            if location == 0:
+                newNode.next = self.head
+                self.head = newNode
+            # insert at last: Time: O(1)
+            elif location == -1:
+                newNode.next = None
+                self.tail.next = newNode
+                self.tail = newNode
+            # insert at nth postion: Time: O(n)
+            else:
+                tempNode = self.head
+                index = 0
+                while index < location - 1:
+                    tempNode = tempNode.next
+                    index += 1
+                nextNode = tempNode.next
+                tempNode.next = newNode
+                newNode.next = nextNode
+
+    def delete_element(self, location):
+        if self.head is None:
+            print("Linked List does not exist")
+
+        else:
+            if location == 0:
+                # if have only one node
+                if self.head == self.tail:
+                    self.head = None
+                    self.tail = None
+                else:
+                    temp = self.head
+                    self.head = temp.next
+                    temp = None
+
+            # delete from last position : Time: O(n)
+            elif location == -1:
+                # #1. if we have only one node
+                if(self.head == self.tail):
+                    self.head = None
+                    self.tail = None
+                else:
+                    # 2. Else, traverse to the second last
+                    #   element of the list
+                    tempNode = self.head
+                    while(tempNode is not None):
+                        if tempNode.next == self.tail:
+                            break
+                        tempNode = tempNode.next
+                    # 3. Change the next of the second
+                    #   last node to null and delete the
+                    #   last node
+                    tempNode.next = None
+                    self.tail = tempNode
+
+            else:
+                tempNode = self.head
+                index = 0
+                while index < location - 1:
+                    tempNode = tempNode.next
+                    index += 1
+                delNode = tempNode.next
+                tempNode.next = delNode.next
+    
+    # Delete whole SLL
+    # Time: O(1) ; Space: O(1)
+    def deleteAllSLL(self):
+        # Idea is to make reference to head and tail to null
+        # Garbage collector then destroy all node
+        if self.head is None:
+            print("The SLL does not exist")
+        else:
+            self.head = None
+            self.tail = None
+
+
+singlyLinkedList = SLinkedList()
+
+singlyLinkedList.insert_element(0, 0)
+singlyLinkedList.insert_element(1, 0)
+singlyLinkedList.insert_element(2, 0)
+
+singlyLinkedList.insert_element(10, -1)
+singlyLinkedList.insert_element(15, -1)
+
+singlyLinkedList.insert_element(20, 3)
+singlyLinkedList.insert_element(25, 4)
+
+print(singlyLinkedList)
+
+singlyLinkedList.delete_element(4)
+singlyLinkedList.delete_element(0)
+singlyLinkedList.delete_element(-1)
+print(singlyLinkedList)
+
+singlyLinkedList.deleteAllSLL()
+print(singlyLinkedList)

LinkedList/LinkedList2.py

@@ -0,0 +1,55 @@
+from random import randint
+
+class Node:
+    def __init__(self, value=None) -> None:
+        self.value = value
+        self.next = None
+    
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+class LinkedList:
+    def __init__(self) -> None:
+        self.head = None
+        self.tail = None
+
+    def __iter__(self):
+        node = self.head
+        while node:
+            yield node
+            node = node.next
+
+    def __str__(self) -> str:
+        values = [str(x.value) for x in self]
+        return ' -> '.join(values)
+    
+    def __len__(self):
+        result = 0
+        node = self.head
+        while node:
+            result += 1
+            node = node.next
+        return result
+    
+    def add(self, value):
+        if self.head is None:
+            newNode = Node(value)
+            self.head = newNode
+            self.tail = newNode
+        else:
+            self.tail.next = Node(value)
+            self.tail = self.tail.next
+        return self.tail
+    
+    def generate(self, n, min_value, max_value):
+        self.head = None
+        self.tail = None
+        for i in range(n):
+            self.add(randint(min_value, max_value))
+        return self
+
+newLL = LinkedList()
+newLL.generate(10, 0, 99)
+print(newLL)
+print(len(newLL))

LinkedList/RemoveDuplicates.py

@@ -0,0 +1,27 @@
+from LinkedList2 import LinkedList
+
+# Remove duplicates elemnent from linked list
+def removeDuplicates(ll):
+    if ll.head is None:
+        return
+    else:
+        curNode = ll.head
+        visitedNode = set([curNode.value])
+        while curNode.next:
+            if curNode.next.value in visitedNode:
+                curNode.next = curNode.next.next
+            else:
+                visitedNode.add(curNode.next.value)
+                curNode = curNode.next
+        return ll
+
+# Implement an algorithm to find the nth from the last element of a singly linked list
+
+
+
+customLL = LinkedList()
+customLL.generate(10, 0, 99)
+print(customLL)
+removeDuplicates(customLL)
+print(customLL)
+    

Tree/BinaryTree.py

@@ -0,0 +1,156 @@
+'''
+ Creation of Binary Tree using Linked List
+ - Creation of Tree
+ - Insertion of a node
+ - Deletion of a node
+ - Search for a value
+ - Traverse all nodes -> 4 ways of traversing
+ - Deletion of tree
+
+ * Traversal of Binary Tree
+    - Depth First Search
+        - Preorder traversal
+        - Inorder traversal
+        - Post order traversal
+    - Breadth first search
+        - Level order traversal
+ '''
+
+from QueueLinkedList import Queue
+
+
+class TreeNode:
+    def __init__(self, data) -> None:
+        self.data = data
+        self.leftChild = None
+        self.rightChild = None
+
+
+BT = TreeNode("Gadgets")
+leftChild = TreeNode("IPad")
+leftChild.leftChild = TreeNode("IPadCharger")
+leftChild.rightChild = TreeNode("IPadEarphone")
+rightChild = TreeNode("Mobile")
+rightChild.rightChild = TreeNode("MobileCharger")
+BT.leftChild = leftChild
+BT.rightChild = rightChild
+
+
+# Time: O(n) ; Space: O(n)
+def preOrderTraversal(rootNode):
+    if not rootNode:
+        return
+    print(rootNode.data)
+    preOrderTraversal(rootNode.leftChild)
+    preOrderTraversal(rootNode.rightChild)
+
+# Time: O(n); Space: O(n)
+def inOrderTraversal(rootNode):
+    if not rootNode:
+        return
+    inOrderTraversal(rootNode.leftChild)
+    print(rootNode.data)
+    inOrderTraversal(rootNode.rightChild)
+
+# Time: O(n); Space: O(n)
+def postOrderTraversal(rootNode):
+    if not rootNode:
+        return
+    postOrderTraversal(rootNode.leftChild)
+    postOrderTraversal(rootNode.rightChild)
+    print(rootNode.data)
+
+# Time: O(n); Space: O(n)
+def levelOrderTraversal(rootNode):
+    if not rootNode:
+        return
+    else:
+        customQueue = Queue()
+        customQueue.enqueue(rootNode)
+        while not customQueue.isEmpty():
+            root = customQueue.dequeue()
+            print(root.value.data)
+            if (root.value.leftChild is not None):
+                customQueue.enqueue(root.value.leftChild)
+
+            if (root.value.rightChild is not None):
+                customQueue.enqueue(root.value.rightChild)
+
+# Time: O(n); Space: O(n)
+def searchValueBT(rootNode, nodeValue):
+    if not rootNode:
+        return "The Binary Tree does not exist"
+    else:
+        customQueue = Queue()
+        customQueue.enqueue(rootNode)
+        while not customQueue.isEmpty():
+            root = customQueue.dequeue()
+            if root.value.data == nodeValue:
+                return "Value found Sucessfully!"
+
+            if (root.value.leftChild is not None):
+                customQueue.enqueue(root.value.leftChild)
+
+            if (root.value.rightChild is not None):
+                customQueue.enqueue(root.value.rightChild)
+        return "Value not found!"
+
+# Insert a node in Binary Tree
+# we do level order traversal to insert node 
+# Since it is queue and it is efficient than recursion(PreOrder, InOrder, PostOrder)
+# Case1: A root node is blank
+# Case2: The tree exists and we have to look for a first vacant place
+# Time: O(n); Space: O(n)
+def insertNodeBT(rootNode, newNode):
+    if not rootNode:
+        rootNode = newNode
+    else:
+        customQueue = Queue()
+        customQueue.enqueue(rootNode)
+        while not customQueue.isEmpty():
+            root = customQueue.dequeue()
+            if root.value.leftChild is not None:
+                customQueue.enqueue(root.value.leftChild)
+            else:
+                root.value.leftChild = newNode
+                return "New Value inserted sucessfully!"
+           
+            if root.value.rightChild is not None:
+                customQueue.enqueue(root.value.rightChild)
+            else:
+                root.value.rightChild = newNode
+                return "New Value inserted sucessfully!"
+
+def getFarthestNode(rootNode):
+    if not rootNode:
+        return
+    else:
+        customQueue = Queue()
+        customQueue.enqueue(rootNode)
+        while not customQueue.isEmpty():
+            root = customQueue.dequeue()
+            
+            if root.value.leftChild is not None:
+                customQueue.enqueue(root.value.leftChild)
+            if root.value.rightChild is not None:
+                customQueue.enqueue(root.value.rightChild)
+        # the last node is farthest among all
+        return root.value
+
+preOrderTraversal(BT)
+print("###########")
+inOrderTraversal(BT)
+print("#######")
+postOrderTraversal(BT)
+print("############")
+levelOrderTraversal(BT)
+print("##########")
+print(searchValueBT(BT, "MobileCharger"))
+print("##########")
+# Insert new node in BT
+newNode = TreeNode("MobileEarphone")
+print(insertNodeBT(BT, newNode))
+levelOrderTraversal(BT)
+print("#########")
+farthestNode = getFarthestNode(BT)
+print(farthestNode.data)

Tree/QueueLinkedList.py

@@ -0,0 +1,78 @@
+
+
+class Node:
+    def __init__(self, value=None) -> None:
+        self.value = value
+        self.next = None
+    
+    def __str__(self) -> str:
+        return str(self.value)
+    
+class LinkedList:
+    def __init__(self) -> None:
+        self.head = None
+        self.tail = None
+
+    def __iter__(self):
+        node = self.head
+        while node:
+            yield node
+            node = node.next
+        
+    
+class Queue:
+    def __init__(self) -> None:
+        self.linkedList = LinkedList()
+
+    def __str__(self) -> str:
+        values = [str(x) for x in self.linkedList]
+        return ' '.join(values)
+    
+    def enqueue(self, value):
+        newNode = Node(value)
+        if self.linkedList.head == None:
+            self.linkedList.head = newNode
+            self.linkedList.tail = newNode
+        else:
+            self.linkedList.tail.next = newNode
+            self.linkedList.tail = newNode
+    
+    def isEmpty(self):
+        if self.linkedList.head == None:
+            return True
+        else:
+            return False
+    
+    def dequeue(self):
+        if self.isEmpty():
+            return "Queue Underflow! No any element."
+        else:
+            tempNode = self.linkedList.head
+            if self.linkedList.head == self.linkedList.tail:
+                self.linkedList.head = None
+                self.linkedList.tail = None
+            else:
+                self.linkedList.head = self.linkedList.head.next
+            return tempNode
+
+    def peek(self):
+        if self.isEmpty():
+            return "Queue Underflow! No any element."
+        else:
+            return self.linkedList.head
+
+    
+    def deleteQueue(self):
+        self.linkedList.head = None
+        self.linkedList.tail = None
+
+    
+custQueue = Queue()
+custQueue.enqueue(10)
+custQueue.enqueue(11)
+custQueue.enqueue(12)
+print(custQueue)
+print(custQueue.dequeue())
+print(custQueue)
+print(custQueue.peek())
+print(custQueue)

Tree/Tree.py

@@ -0,0 +1,31 @@
+ 
+
+ 
+
+class TreeNode:
+    def __init__(self, data, children=[]) -> None:
+        self.data = data
+        self.children = children
+    
+    def __str__(self, level=0) -> str:
+        ret = " " * level + str(self.data) + "\n"
+        for child in self.children:
+            ret += child.__str__(level + 1)
+        return ret
+    
+    def addChild(self, TreeNode):
+        self.children.append(TreeNode)
+    
+
+tree = TreeNode('Gadgets', [])
+Ipad = TreeNode('Ipad', [])
+mobile = TreeNode('Mobile', [])
+tree.addChild(Ipad)
+tree.addChild(mobile)
+
+IpadCharger = TreeNode('IpadCharger', [])
+mobileCharger = TreeNode('MobileCharger', [])
+Ipad.addChild(IpadCharger)
+mobile.addChild(mobileCharger)
+print(tree)
+