added standard questions for trees

Trees/balanced.py

@@ -0,0 +1,36 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import deque
+def isbalanced(root):
+    if root is None:
+        return 0
+    lh = isbalanced(root.left)
+    if lh == 0:
+        return 0
+    rh = isbalanced(root.right)
+    if rh == 0:
+        return 0
+    if (abs(lh - rh) > 1):
+        return 0
+    else:
+        return max(lh, rh) + 1
+
+# def is_balanced_iterative(root):
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+
+if isbalanced(root)==0:
+    print('not balanced')
+else:
+    print('balanced')
+# print(is_balanced_iterative(root))

Trees/bottomview.py

@@ -0,0 +1,41 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import defaultdict,deque
+def bottomview_iterative(root):
+    if not root:
+        return []
+    queue = deque([(root, 0)])
+    ans=defaultdict(int)
+    while queue:
+        node, level = queue.popleft()
+        ans[level]=node.data
+        if node.left:
+            queue.append((node.left, level-1))
+        if node.right:
+            queue.append((node.right, level+1))
+    print([ans[i] for i in range(min(ans),max(ans)+1)])
+
+def bottomview_recursive(root,level,res):
+    if not root:
+        return
+    res[level]=root.data
+    bottomview_recursive(root.left,level-1,res)
+    bottomview_recursive(root.right,level+1,res)
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+
+bottomview_iterative(root)
+
+res=defaultdict(int)
+bottomview_recursive(root,0,res)
+print([res[i] for i in range(min(res),max(res)+1)])

Trees/boundary.py

@@ -0,0 +1,40 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+class Solution:
+    def isleaf(self,root):
+        return not root.left and not root.right
+    def addleaves(self,root,ans):
+        if self.isleaf(root):
+            ans.append(root.val)
+            return 
+        if root.left:
+            self.addleaves(root.left,ans)
+        if root.right:
+            self.addleaves(root.right,ans)
+    def boundary(self, root: Optional[TreeNode]) -> List[int]:
+        if not root:return []
+        ans=[]
+        if not self.isleaf(root):
+            ans+=[root.val]
+        tmp=root.left
+        while tmp:
+            if not self.isleaf(tmp):
+                ans+=[tmp.val]
+            if tmp.left:
+                tmp=tmp.left
+            else:
+                tmp=tmp.right
+        self.addleaves(root,ans)
+        tmp=root.right
+        s=[]
+        while tmp:
+            if not self.isleaf(tmp):
+                s.append(tmp.val)
+            if tmp.right:
+                tmp=tmp.right
+            else:
+                tmp=tmp.left
+        return ans+s[::-1]

Trees/depth.py

@@ -0,0 +1,36 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import deque
+def depth(root):
+    if not root:
+        return 0
+    return 1+max(depth(root.left),depth(root.right))
+
+def depth_iterative(root):
+    if not root:
+        return 0
+    queue=deque([(root,1)])
+    ans=0
+    while queue:
+        node,level=queue.popleft()
+        ans=max(ans,level)
+        if node.left:
+            queue.append((node.left,level+1))
+        if node.right:
+            queue.append((node.right,level+1))
+    return ans
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+
+print(depth(root))
+print(depth_iterative(root))

Trees/inorder.py

@@ -0,0 +1,50 @@
+class Node():
+    def __init__(self,data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+def inorder_recursive(root):
+    if root:
+        inorder_recursive(root.left)
+        print(root.data)
+        inorder_recursive(root.right)
+
+def inorder_iterative(root):
+    stack = []
+    current = root
+    while True:
+        if current:
+            stack.append(current)
+            current = current.left
+        elif stack:
+            current = stack.pop()
+            print(current.data)
+            current = current.right
+        else:
+            break
+
+def moris_inorder(root):
+    current = root
+    while current:
+        if current.left:
+            pre = current.left
+            while pre.right and pre.right != current:
+                pre = pre.right
+            if pre.right == current:
+                pre.right = None
+                print(current.data)
+                current = current.right
+            else:
+                pre.right = current
+                current = current.left
+        else:
+            print(current.data)
+            current = current.right
+root = Node(1)
+root.left = Node(2)
+root.right = Node(3)
+root.left.left = Node(4)
+root.left.right = Node(5)
+inorder_recursive(root)
+inorder_iterative(root)

Trees/issametree.py

@@ -0,0 +1,15 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+def issametree(p,q):
+    if not p and not q:
+        return True
+    if not q or not p:
+        return False
+    if p.val != q.val:
+        return False
+    return issametree(p.right, q.right) and issametree(p.left, q.left)
+

Trees/issymmetric.py

@@ -0,0 +1,29 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+def issymmetric(root):
+    if not root:    
+        return True
+    def helper(left,right):
+        if not left and not right:
+            return True
+        if not left or not right:
+            return False
+        if left.data!=right.data:
+            return False
+        return helper(left.left,right.right) and helper(left.right,right.left)
+    return helper(root.left,root.right)
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+print(issymmetric(root))
+
+# Path: trees\levelorder.py?

Trees/leftview.py

@@ -0,0 +1,42 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import deque,defaultdict
+def leftview_iterative(root):
+    if not root:
+        return []
+    queue = deque([(root, 0)])
+    ans=[]
+    while queue:
+        node, level = queue.popleft()
+        if level==len(ans):
+            ans.append(node.data)
+        if node.left:
+            queue.append((node.left, level+1))
+        if node.right:
+            queue.append((node.right, level+1))
+    print(ans)
+
+def leftview_recursive(root,level,res):
+    if not root:
+        return 
+    if len(res)==level:
+        res.append(root.data)
+    leftview_recursive(root.left,level+1,res)
+    leftview_recursive(root.right,level+1,res)
+
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+leftview_iterative(root)
+res=[]
+leftview_recursive(root,0,res)
+print(res)

Trees/levelorder.py

@@ -0,0 +1,31 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import defaultdict,deque
+def levelorder(root):
+    if not root:
+        return
+    a=defaultdict(list)
+    queue=deque([(root,0)])
+    while queue:
+        node,level=queue.popleft()
+        a[level].append(node.data)
+        if node.left:
+            queue.append((node.left,level+1))
+        if node.right:
+            queue.append((node.right,level+1))
+    print(a.values())
+
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+
+levelorder(root)

Trees/maxwidth.py

@@ -0,0 +1,30 @@
+class Node():
+    def __init__(self,data):
+        self.data=data
+        self.left=None
+        self.right=None
+
+from collections import deque
+def max_width(root):
+    queue=deque([(root,1)])
+    ans=0
+    while queue:
+        n=len(queue)
+        ans=max(ans,queue[-1][1]-queue[0][1]+1)
+        for _ in range(n):
+            node,number=queue.popleft()
+            if node.left:
+                queue.append((node.left,2*number))
+            if node.right:
+                queue.append((node.right,2*number +1))
+    return ans
+
+root=Node(4)
+root.left=Node(5)
+root.right=Node(2)
+root.right.left=Node(3)
+root.right.right=Node(1)
+root.right.left.left=Node(6)
+root.right.left.right=Node(7)
+
+print(max_width(root))