二叉树

二叉树的建立：递归和迭代

• 前序遍历+中序遍历

  剑指 Offer 07. 重建二叉树 中等

  def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
  	if not inorder:
  	    return None
  	root_val = preorder.pop(0)
  	index_root = inorder.index(root_val)
  	root = TreeNode(root_val)
  	root.left = self.buildTree(preorder,inorder[:index_root])
  	root.right = self.buildTree(preorder,inorder[index_root+1:])
  	return root
  
  

    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder:
            return None
        
        root = TreeNode(preorder[0])
        length = len(preorder)
        stack = []
        stack.append(root)
        index = 0
        for i in range(1, length):
            preorderval = preorder[i]
            node = stack[-1]
            if node.val != inorder[index]: # 每次比较栈顶元素和inorder[index]
                node.left = TreeNode(preorderval)
                stack.append(node.left)
            else:
                while stack and stack[-1].val == inorder[index]:# 栈顶元素等于inorder[index],弹出；并且index += 1
                    node = stack[-1]
                    stack.pop()
                    index += 1
                node.right = TreeNode(preorderval)
                stack.append(node.right)
        return root

二叉树的遍历

101. 对称二叉树
迭代（层次遍历，判断每层的值是否回文）+递归（左左右右以及值的判断）

    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        
        queue = [root]
        
        while(queue):
            next_queue = list()
            layer = list()
            for node in queue:
                if not node:
                    layer.append(None)
                    continue
                next_queue.append(node.left)
                next_queue.append(node.right)
                
                layer.append(node.val)
                
            if layer != layer[::-1]:
                return False
            queue = next_queue
            
        return True

    def isSymmetric(self, root: TreeNode) -> bool:
        
        return self.check(root,root)
    def check(self,p,q):
        # 都不存在（0,0）
        if p==None and q==None: return True
        # (1,0)(0,1)
        if p==None or q==None : return False

        return p.val==q.val and self.check(p.left,q.right) and self.check(p.right,q.left)

437. 路径总和 III 简单
双重递归的操作，从每个节点开始进行类似的计算，所以第一个递归用来遍历这些节点，这二个递归用来处理这些节点，进行深度优先搜索

    def pathSum(self, root: TreeNode, s: int) -> int:
        # 中序遍历递归
        def Sum(node,tar):
            if not node:return 0
            tar-=node.val
            if tar==0:  res=1
            else: res = 0
            res += Sum(node.left,tar)
            res += Sum(node.right,tar)
            return res
       
        if not root:return 0
        res = Sum(root,s)
        res += self.pathSum(root.left,s)
        res += self.pathSum(root.right,s)

        return res

617. 合并二叉树 简单
递归

    def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        if t1 and t2 :
            t1.val += t2.val
            t1.left = self.mergeTrees(t1.left, t2.left)
            t1.right = self.mergeTrees(t1.right, t2.right)
            return t1
        return t1 or t2

104. 二叉树的最大深度 简单
递归DFS+层次遍历迭代

    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return Math.max(left, right) + 1;
    }

    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        ans = 0
        while queue:
            ans += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return ans

226. 翻转二叉树 简单
递归DFS

    def invertTree(self, root: TreeNode) -> TreeNode:
        # 先序遍历--从顶向下交换
        if not root:return root
        right = root.right
        root.right = self.invertTree(root.left)
        root.left = self.invertTree(right)
        return root

543. 二叉树的直径 简单
递归DFS

    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        # 每个节点的左右子树的高度和 的最大值
        self.res = 0
        if not root:return 0
        def dfs(node: TreeNode) -> int:
            if not node:return 0
            left = dfs(node.left)
            right = dfs(node.right)
            self.res = max(self.res,left+right)
            return max(left,right)+1
        dfs(root)
        return self.res

538. 把二叉搜索树转换为累加树 简单
反过来的中序遍历+迭代

    def convertBST(self, root: TreeNode) -> TreeNode:
        if not root:return root
        cur = root
        stack = []
        s = 0
        while stack or root:
            if root:
                while root:
                    stack.append(root)
                    root = root.right
            else:
                node = stack.pop()
                node.val += s
                s = node.val
                root = node.left
        return cur

	int num = 0;

    public TreeNode convertBST(TreeNode root) {
        if (root != null) {
            //遍历右子树
            convertBST(root.right);
            //遍历顶点
            root.val = root.val + num;
            num = root.val;
            //遍历左子树
            convertBST(root.left);
            return root;
        }
        return null;
    }