resuming dsa

Author: kunalarya873

CheckBalanced.py

@@ -0,0 +1,41 @@
+#   Created by Elshad Karimov 
+#   Copyright © AppMillers. All rights reserved.
+
+# Balanced Tree
+
+def isBalancedHelper(root):
+    if root is None:
+        return 0
+    leftHeight = isBalancedHelper(root.left)
+    if leftHeight == -1:
+        return -1
+    rightHeight = isBalancedHelper(root.right)
+    if rightHeight == -1:
+        return -1
+    if abs(leftHeight-rightHeight)>1:
+        return -1
+    
+    return max(leftHeight, rightHeight) + 1
+
+def isBalanced(root):
+    return isBalancedHelper(root) > -1
+
+class Node():
+    def __init__(self, value, left=None, right=None):
+        self.value = value
+        self.left = left
+        self.right = right
+
+N1 = Node("N1")
+N2 = Node("N2")
+N3 = Node("N3")
+N4 = Node("N4")
+N5 = Node("N5")
+N6 = Node("N6")
+N1.left = N2
+N1.right = N3
+N2.left = N4
+N2.right = N5
+N3.right = N6
+
+print(isBalanced(N1))

DSA-Python.pdf

@@ -0,0 +1,23 @@
+#   Created by Elshad Karimov 
+#   Copyright © AppMillers. All rights reserved.
+
+# Minimum Cost in 2D array
+
+def findMinCost(twoDArray, row, col):
+    if row == -1 or col == -1:
+        return float('inf')
+    elif row == 0 and col == 0:
+        return twoDArray[0][0]
+    else:
+        op1 = findMinCost(twoDArray, row-1, col)
+        op2 = findMinCost(twoDArray, row, col-1)
+        return twoDArray[row][col] + min(op1,op2)
+
+TwoDList = [[4,7,8,6,4],
+           [6,7,3,9,2],
+           [3,8,1,2,4],
+           [7,1,7,3,7],
+           [2,9,8,9,3]
+           ]
+
+print(findMinCost(TwoDList, 4,4))

Data+Structures+and+Algorithms+Bootcamp+in+Python+slides+Remaster.pdf

@@ -0,0 +1,30 @@
+#   Created by Elshad Karimov 
+#   Copyright © AppMillers. All rights reserved.
+
+# Number of paths to reach the last cell with given cost in 2D array
+
+def numberOfPaths(twoDArray, row, col, cost):
+    if cost < 0:
+        return 0
+    elif row == 0 and col == 0:
+        if twoDArray[0][0] - cost == 0:
+            return 1
+        else:
+            return 0
+    elif row == 0:
+        return numberOfPaths(twoDArray, 0, col-1, cost - twoDArray[row][col] )
+    elif col == 0:
+        return numberOfPaths(twoDArray, row-1, 0, cost - twoDArray[row][col] )
+    else:
+        op1 = numberOfPaths(twoDArray, row -1, col, cost - twoDArray[row][col] )
+        op2 = numberOfPaths(twoDArray, row, col-1, cost - twoDArray[row][col] )
+        return op1 + op2
+
+
+TwoDList = [[4,7,1,6],
+           [5,7,3,9],
+           [3,2,1,2],
+           [7,1,6,3]
+           ]
+
+print(numberOfPaths(TwoDList, 3,3, 25))

MinCost2D.py

@@ -0,0 +1,66 @@
+#   Created by Elshad Karimov 
+#   Copyright © AppMillers. All rights reserved.
+
+# Validate BST
+
+class Node: 
+	def __init__(self, key): 
+		self.data = key 
+		self.left = None
+		self.right = None
+
+def minValue(node):
+    current = node
+    while (current is not None):
+        if current.left is None:
+            break
+        current = current.left
+    return current
+
+def inOrderSuccessor(root, n):
+    if n.right is not None:
+        return minValue(n.right)
+    
+    p = n.parent
+    while p is not None:
+        if n != p.right:
+            break
+        n = p
+        p = p.parent
+    return p 
+
+def insert(node, data):
+   if node is None:
+       return Node(data)
+   else:
+       if data <= node.data:
+           temp = insert(node.left, data)
+           node.left = temp
+           temp.parent = node
+       else:
+           temp = insert(node.right, data)
+           node.right = temp
+           temp.parent = node      
+       return node
+
+root = None
+root = insert(root, 4)
+root = insert(root, 2)
+root = insert(root, 8)
+root = insert(root, 1)
+root = insert(root, 3)
+root = insert(root, 5)
+root = insert(root, 9)
+
+temp = root.left #2
+
+successor = inOrderSuccessor(root, temp)
+print(successor.data)
+
+if successor is not None:
+    print("Inorder successor of %d is %d" %(temp.data, successor.data))
+else:
+    print("Inorder successor does not exist")
+
+
+

NumberofPaths.py

@@ -0,0 +1,40 @@
+#   Created by Elshad Karimov 
+#   Copyright © AppMillers. All rights reserved.
+
+# Validate BST
+
+class TreeNode:
+     def __init__(self, value):
+         self.val = value
+         self.left = None
+         self.right = None
+
+def helper(node, minValue = float('-inf'), maxValue = float('inf')):
+    if not node:
+        return True
+    val = node.val
+    if val <= minValue or val >= maxValue:
+        return False
+    
+    if not helper(node.right, val, maxValue):
+        return False
+    
+    if not helper(node.left, minValue, val):
+        return False
+    
+    return True
+
+def isValidBST(root):
+    return helper(root)
+
+root1 = TreeNode(2)
+root1.left = TreeNode(1)
+root1.right = TreeNode(4)
+
+print(isValidBST(root1))
+
+root2 = TreeNode(4)
+root2.left = TreeNode(1)
+root2.right = TreeNode(3)
+
+print(isValidBST(root2))

Successor.py

@@ -54,7 +54,8 @@ def add_after(self, data, value):
             new_node = Node(data)
             new_node.ref = temp.ref
             temp.ref = new_node
-
+    def add_before(self, data, value):
+        pass
 
 obj1 = LinkedList()
 obj1.add_starting(10)