quick binary tree

binary-tree.py

class Tree:
    def __init__(self, data):
        self.left = None
        self.right = None
        self.data = data
        
    def insert(self, data):
        if self.data:
            if isinstance(self.data, int):
                if self.left is None:
                    self.left = Tree(data)
                else:
                    self.left.insert(data)
            elif data >= self.data:
                if self.right is None:
                    self.right = Tree(data)
                else:
                    self.right.insert(data)
        else:
            self.data = data

    def inorder_traversal(self, root):
        res = []
        if root:
            res = self.inorderTraversal(root.left)
            res.append(root.data)
            res = res + self.inorderTraversal(root.right)
        return res

    def postorder_traversal(self, root: 'TreeNode'):
        stack = [root]
        res = []
        while stack:
            n = stack.pop()
            res.append(n.val)
            if n.left:
                stack.append(n.left)
            if n.right:
                stack.append(n.right)
        res = res[::-1]
        return res
        
    def preorder_recusive(self, root):
        res = []
        if root:
            res.append(root.data)
            res += self.preorder_recursive(root.left)
            res += self.preorder_recursive(root.right)
        return res
        
    def inorder_iterative(self, root):
        ans = []
        node = root
        S = []
        while node or S:
            if node:
                S.append(node)
                node = node.left
            else:
                node = S.pop()
                ans.append(node.val)
                node = node.right
        return ans
      
"""
example usage
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        root = Tree(nums[0]**2)
        for n in nums[1:]:
            print('n',n)
            sq = n**2
            root.insert(sq)
        return root.inorderTraversal(root)
 """