diff --git a/Trees/balanced.py b/Trees/balanced.py new file mode 100644 index 0000000..f27dc63 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/Trees/bottomview.py b/Trees/bottomview.py new file mode 100644 index 0000000..61e5ca9 --- /dev/null +++ b/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)]) \ No newline at end of file diff --git a/Trees/boundary.py b/Trees/boundary.py new file mode 100644 index 0000000..d8d5c49 --- /dev/null +++ b/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] \ No newline at end of file diff --git a/Trees/depth.py b/Trees/depth.py new file mode 100644 index 0000000..15ccb9f --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/Trees/inorder.py b/Trees/inorder.py new file mode 100644 index 0000000..060786a --- /dev/null +++ b/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) diff --git a/Trees/issametree.py b/Trees/issametree.py new file mode 100644 index 0000000..bf026f2 --- /dev/null +++ b/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) + diff --git a/Trees/issymmetric.py b/Trees/issymmetric.py new file mode 100644 index 0000000..08915b4 --- /dev/null +++ b/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? \ No newline at end of file diff --git a/Trees/leftview.py b/Trees/leftview.py new file mode 100644 index 0000000..28d9e8c --- /dev/null +++ b/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) \ No newline at end of file diff --git a/Trees/levelorder.py b/Trees/levelorder.py new file mode 100644 index 0000000..867fb3d --- /dev/null +++ b/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) \ No newline at end of file diff --git a/Trees/maxwidth.py b/Trees/maxwidth.py new file mode 100644 index 0000000..559e367 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/Trees/postorder.py b/Trees/postorder.py new file mode 100644 index 0000000..ec912c4 --- /dev/null +++ b/Trees/postorder.py @@ -0,0 +1,39 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None + +def postorder_recursive(root): + if root: + postorder_recursive(root.left) + postorder_recursive(root.right) + print(root.data) + +def postorder_iterative(root): + st=[] + while True: + if root: + st.append(root) + root=root.left + elif st: + tmp=st[-1].right + if tmp: + root=tmp + else: + tmp=st.pop() + print(tmp.data) + while st and tmp==st[-1].right: + tmp=st.pop() + print(tmp.data) + else: + break + +root = Node(1) +root.left = Node(2) +root.right = Node(3) +root.left.left = Node(4) +root.left.right = Node(5) + +postorder_recursive(root) +postorder_iterative(root) \ No newline at end of file diff --git a/Trees/preorder.py b/Trees/preorder.py new file mode 100644 index 0000000..29883e4 --- /dev/null +++ b/Trees/preorder.py @@ -0,0 +1,34 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None + +def preorer_recursive(root): + if root: + print(root.data) + preorer_recursive(root.left) + preorer_recursive(root.right) + +def preorder_iterative(root): + st=[] + while 1: + if root: + print(root.data) + st.append(root) + root=root.left + elif st: + tmp=st.pop() + root=tmp.right + else: + break + +root = Node(1) +root.left = Node(2) +root.right = Node(3) +root.left.left = Node(4) +root.left.right = Node(5) + +preorer_recursive(root) + +preorder_iterative(root) \ No newline at end of file diff --git a/Trees/rightview.py b/Trees/rightview.py new file mode 100644 index 0000000..7c53a5a --- /dev/null +++ b/Trees/rightview.py @@ -0,0 +1,40 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None +from collections import deque +def rightview_recursive(root,level,res): + if not root: + return + if len(res)==level: + res.append(root.data) + rightview_recursive(root.right,level+1,res) + rightview_recursive(root.left,level+1,res) + +def rightview_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.right: + queue.append((node.right, level+1)) + if node.left: + queue.append((node.left, level+1)) + print(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) +res=[] +rightview_recursive(root,0,res) +print(res) +rightview_iterative(root) \ No newline at end of file diff --git a/Trees/roottonode.py b/Trees/roottonode.py new file mode 100644 index 0000000..e2dbe5e --- /dev/null +++ b/Trees/roottonode.py @@ -0,0 +1,29 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None + +def root_to_node(root,ans,x): + if not root: + return False + ans.append(root.data) + if root.data==x: + return True + if root_to_node(root.left,ans,x) or root_to_node(root.right,ans,x): + return True + ans.pop() + return False + + +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) + +ans=[] +root_to_node(root,ans,6) +print(ans) \ No newline at end of file diff --git a/Trees/subarrays.py b/Trees/subarrays.py new file mode 100644 index 0000000..de1700d --- /dev/null +++ b/Trees/subarrays.py @@ -0,0 +1,2 @@ +def subarray(nums): + # number of contiguos subarrays of nums such that abs(max-min) is <=2? \ No newline at end of file diff --git a/Trees/topview.py b/Trees/topview.py new file mode 100644 index 0000000..22f8e4b --- /dev/null +++ b/Trees/topview.py @@ -0,0 +1,44 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None + +from collections import defaultdict,deque +def topview_iterative(root): + a=defaultdict(int) + queue=deque([(root,0)]) + leftmost,rightmost=0,0 + while queue: + node,level=queue.popleft() + if not a[level]: + a[level]=node.data + if node.left: + queue.append((node.left,level-1)) + leftmost=min(leftmost,level-1) + if node.right: + queue.append((node.right,level+1)) + rightmost=max(rightmost,level+1) + print([a[i] for i in range(leftmost,rightmost+1)]) + +def topview_recursive(root,level,res): + if not root: + return + if not res[level]: + res[level]=root.data + topview_recursive(root.left,level-1,res) + topview_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) + +topview_iterative(root) + +res=defaultdict(int) +topview_recursive(root,0,res) +print([res[i] for i in range(min(res),max(res)+1)]) diff --git a/Trees/treeusing_postandin.py b/Trees/treeusing_postandin.py new file mode 100644 index 0000000..916ba8f --- /dev/null +++ b/Trees/treeusing_postandin.py @@ -0,0 +1,19 @@ +class Node(): + def __init__(self, data): + self.data = data + self.left = None + self.right = None + +def buildtree(inorder,postorder): + if not inorder: + return None + root=Node(postorder[-1]) + mid=inorder.index(postorder[-1]) + root.left=buildtree(inorder[:mid],postorder[:mid]) + root.right=buildtree(inorder[mid+1:],postorder[mid:-1]) + return root + +inorder = [9,3,15,20,7] +postorder = [9,15,7,20,3] +print(buildtree(inorder,postorder)) + diff --git a/Trees/treeusing_preandin.py b/Trees/treeusing_preandin.py new file mode 100644 index 0000000..2b376f3 --- /dev/null +++ b/Trees/treeusing_preandin.py @@ -0,0 +1,18 @@ +class Node(): + def __init__(self, data): + self.data = data + self.left = None + self.right = None + +def build_tree_using_inorder_and_preorder(preorder,inorder): + if not inorder: + return None + root = Node(preorder[0]) + mid = inorder.index(preorder[0]) + root.left = build_tree_using_inorder_and_preorder(preorder[1:mid+1],inorder[:mid]) + root.right = build_tree_using_inorder_and_preorder(preorder[mid+1:],inorder[mid+1:]) + return root + +preorder = [3,9,20,15,7] +inorder = [9,3,15,20,7] +print(build_tree_using_inorder_and_preorder(preorder,inorder)) \ No newline at end of file diff --git a/Trees/verticalorder.py b/Trees/verticalorder.py new file mode 100644 index 0000000..05eeecf --- /dev/null +++ b/Trees/verticalorder.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 verticalorder(root): + a=defaultdict(list) + queue=deque([(root,0)]) + while queue: + node,level=queue.popleft() + a[level].append(node.data) + if node.right: + queue.append((node.right,level+1)) + if node.left: + queue.append((node.left,level-1)) + + print(sum([a[i] for i in range(min(a),max(a)+1)],[])) + + + +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) + +verticalorder(root) diff --git a/Trees/zigzag.py b/Trees/zigzag.py new file mode 100644 index 0000000..2c02321 --- /dev/null +++ b/Trees/zigzag.py @@ -0,0 +1,39 @@ +class Node(): + def __init__(self,data): + self.data=data + self.left=None + self.right=None + +from collections import deque +def zigzag(root): + if not root: + return [] + queue=deque([root]) + ans=[] + flag=0 + while queue: + temp=[] + for _ in range(len(queue)): + node=queue.popleft() + temp.append(node.data) + if node.left: + queue.append(node.left) + if node.right: + queue.append(node.right) + if flag==0: + ans.append(temp) + flag=1 + else: + ans.append(temp[::-1]) + flag=0 + 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(zigzag(root)) \ No newline at end of file