new questions

Author: prabhupant

data_structures/array/largest_element.py

@@ -0,0 +1,12 @@
+import sys
+
+def largest(arr):
+    l = -sys.maxsize
+    for i in arr:
+        if i > l:
+            l = i
+    print(l)
+
+arr = [1,2,3,4,5,6,7,8,2,4,5,7,34,56,23,1234,134,57,67,345]
+
+largest(arr)

data_structures/array/three_largest_elements.py

@@ -0,0 +1,20 @@
+import sys
+
+def three_largest(arr):
+    first = second = third = -sys.maxsize
+    for i in arr:
+        if i > first:
+            third = second
+            second = first
+            first = i
+        elif i > second:
+            third = second
+            second = i
+        elif i > third:
+            third = i
+    print(first, second, third)
+
+
+arr = [10,45,3,7,4,6,8,9,4,6,4,23,45,56,47,25,34,67,634]
+three_largest(arr)
+

data_structures/bst/average_of_levels.py

@@ -0,0 +1,33 @@
+import collections
+
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def mean(arr):
+    m = 0
+    for x in arr:
+        m += x
+    return m / len(arr)
+
+
+def bfs(root):
+    if not root:
+        return
+    queue = collections.deque([root])
+    result = []
+    while queue:
+        next_queue = collections.deque()
+        for node in queue:
+            if node.left:
+                next_queue.append(node.left)
+            if node.right:
+                next_queue.append(node.right)
+        result.append(mean(queue))
+        queue = next_queue
+    return result
+

data_structures/bst/bfs.py

@@ -0,0 +1,36 @@
+import collections 
+
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def bfs(root):
+    if not root:
+        return
+    
+    queue = collections.deque([root])
+
+    while queue:
+        temp = queue.popleft()
+        print(temp.val)
+        if temp.right:
+            queue.append(temp.right)
+        if temp.left:
+            queue.append(temp.left)
+
+
+root = Node(3)
+root.right = Node(4)
+root.left = Node(2)
+
+root.left.left = Node(1)
+root.left.right = Node(2.5)
+
+root.right.left = Node(3.5)
+root.right.right = Node(5)
+
+bfs(root)

data_structures/bst/binary_search_tree.py

@@ -0,0 +1,38 @@
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+class BST():
+
+    def __init__(self):
+        self.root = Node(None)
+
+
+    def insert(self, new_data):
+        if self.root is None:
+            self.root = Node(new_data)
+        else:
+            if self.root.val < new_data:
+
+                self.insert(self.root.right, new_data)
+            else:
+                self.insert(self.root.left, new_data)
+
+
+    def inorder(self):
+        if self.root:
+            self.inorder(self.root.left)
+            print(self.root.val)
+            self.inorder(self.root.right)
+
+
+if __name__ == '__main__':
+    tree = BST()
+    tree.insert(5)
+    tree.insert(4)
+    tree.insert(7)
+    tree.inorder()

data_structures/bst/bt_to_bst.py

@@ -0,0 +1,42 @@
+class Node:
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def store_inorder(root, inorder):
+    if root is None:
+        return
+
+    store_inorder(root.left, inorder)
+    inorder.append(root.data)
+    store_inorder(root.right, inorder)
+
+
+def count_nodes(root):
+    if root is None:
+        return 0
+    return count_nodes(root.left) + count_nodes(root.right) + 1
+
+
+def array_to_bst(arr, root):
+    if root is None:
+        return
+    array_to_bst(arr, root.left)
+    root.data = arr[0]
+    arr.pop(0)
+    array_to_bst(arr, root.right)
+
+
+def bt_to_bst(root):
+    if root is None:
+        return
+
+    n = count_nodes(root)
+    arr = []
+    store_inorder(root, arr)
+    arr.sort()
+    array_to_bst(arr, root)
+

data_structures/bst/ceil.py

@@ -0,0 +1,19 @@
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def ceil(root, key):
+    if not root:
+        return -1
+    if root.val == key:
+        return root.val
+    if root.val < key:
+        return ceil(root.right, key)
+    val = ceil(root.left, key)
+    return val if val >= key else root.key
+
+

data_structures/bst/check_bt_is_subtree_of_another_bt.py

@@ -0,0 +1,26 @@
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def check(root1, root2):
+    if root1 == None:
+        return True
+    if root2 == None:
+        return False
+    if are_identical(root1, root2):
+        return True
+    return (check(root1.left, root2) or check(root1.right, root2))
+
+
+def are_identical(root1, root2):
+    if root1 == None and root2 == None:
+        return True
+    if root1 == None or root2 == None:
+        return False
+    return (root1.val == root2.val and are_identical(root1.left, root2.left) and are_identical(root1.right, root2.right))
+
+

data_structures/bst/check_if_bt_if_bst.py

@@ -0,0 +1,27 @@
+import sys
+
+MAX = sys.maxsize
+MIN = -sys.maxsize
+
+class Node:
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def check_BST(root, min, max):
+    if root is None:
+        return True
+
+    if root.val < min or root.val > max:
+        return False
+
+    return (check_BST(root.left, min, root.val - 1) and check_BST(root.right, root.val + 1, max))
+
+root = Node(5)
+root.left = Node(4)
+root.right = Node(7)
+
+print(check_BST(root, MIN, MAX))

data_structures/bst/closest_element.py

@@ -0,0 +1,41 @@
+import sys
+
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def closest_element(root, k):
+    if not root:
+        return None
+    curr = root
+    min_diff = sys.maxsize
+    element = None
+    while curr:
+        if curr.val == k:
+            return curr.val
+        if abs(curr.val - k) < min_diff:
+            min_diff = abs(curr.val - k)
+            element = curr.val
+
+        if curr.val > k:
+            curr = curr.left
+        else:
+            curr = curr.right
+    return element
+
+
+root = Node(5)
+root.left = Node(3)
+root.right = Node(10)
+
+root.left.left = Node(2)
+root.left.right = Node(4)
+
+root.right.right = Node(20)
+root.right.left = Node(8)
+
+print(closest_element(root, 18))

data_structures/bst/convert_bst_to_right_node_tree.py

@@ -0,0 +1,19 @@
+class Node():
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def increasing_bst(root):
+    def inorder(node):
+        if node:
+            yield from inorder(node.left)
+            yield node.val
+            yield from inorder(node.right)
+    ans = curr = Node(None)
+    for v in inorder(root):
+        curr.right = Node(v)
+        curr = curr.right
+    return ans.right

data_structures/bst/deletion.py

@@ -0,0 +1,62 @@
+class Node:
+
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def inorder(root):
+    if not root:
+        return None
+    stack = []
+    while True:
+        if root:
+            stack.append(root)
+            root = root.left
+        else:
+            if not stack:
+                break
+            root = stack.pop()
+            print(root.val, end=" ")
+            root = root.right()
+
+
+def min_value_node(root):
+    curr = root
+    while curr.left:
+        curr = curr.left
+    return curr
+
+
+def delete(root, val):
+    if not root:
+        return root
+
+    if val < root.val:
+        root.left = delete(root.left, val)
+    
+    elif val > root.val:
+        root.right = delete(root.right, val)
+
+    else:
+        # Root with one child or no child
+        if root.left is None:
+            temp = root.right
+            root = None
+            return temp
+
+        elif root.right is None:
+            temp = root.left
+            root = None
+            return temp
+
+        temp = min_value_node(root.right)
+        root.val = temp.val
+        root.right = delete(root.right, temp.val)
+
+    return root
+
+
+
+