【LeetCode】23.二叉树集合

1.二叉树的前序遍历

迭代版：
大概思路：对于二叉树中的任何一个节点而言，它都有两个角色需要扮演，一个是作为值存储的角色（角色1），另一个角色是作为它所带领的子树的一个代表（角色2）。而我们设置的bool变量，就是为了说明我当前拿到的这个节点，应该是以一个值存储的这种角色对待它(True)，还是应该以一个子树的代表这种角色对待它（False），如果是前者，那么就简单的将其所存储的值打印出来，如果是后者，我们需要继续探索由它带领的子树。

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        st=[(root,False)]
        res=[]
        while st:
            cur,vis=st.pop()
            if vis:
                res.append(cur.val)
            else:
                if cur.right:
                    st.append((cur.right,False))
                if cur.left:
                    st.append((cur.left,False))
                st.append((cur,True))
        return res
       

递归版：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def helper(root):
            if root:
                res.append(root.val)
                helper(root.left)
                helper(root.right)
        helper(root)
        return res

2.二叉树的中序遍历

迭代版：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if not root:
            return res
        st=[(root,False)]
        while st:
            cur,vis=st.pop()
            if vis==True:
                res.append(cur.val)
            else:
                if cur.right:
                    st.append((cur.right,False))
                st.append((cur,True))
                if cur.left:
                    st.append((cur.left,False))
        return res

递归版

    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def helper(root):
            if  root:
	            helper(root.left)
	            res.append(root.val)
	            helper(root.right)
        helper(root)
        return res
        

3.后序遍历

迭代版：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if not root:
            return res
        st=[(root,False)]
        while st:
            cur,vis=st.pop()
            if vis==True:
                res.append(cur.val)
            else:
                st.append((cur,True))
                if cur.right:
                    st.append((cur.right,False))
                if cur.left:
                    st.append((cur.left,False))
        return res

递归版：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
    	res=[]
    	def helper(root):
    		if root:
	    		helper(root.left)
	    		helper(root.right)
	    		res.append(root.val)
	    helper(root)
	    reutrun res

4.层次遍历

    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res=[]
        if root == None:
            return res
        cur_level=[root]
        while cur_level:
            cur=[]
            next_level=[]
            for node in cur_level:
                cur.append(node.val)
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            res.append(cur)
            cur_level=next_level
        return res

5.二叉树最大深度（104）

迭代：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        stack=[(root,1)]
        max_depth=0
        while stack:
            node,cur_depth=stack.pop()
            if node:
                max_depth=max(cur_depth,max_depth)
                if node.left:
                    stack.append((node.left,cur_depth+1))
                if node.right:
                    stack.append((node.right,cur_depth+1))
        return max_depth
        
        

迭代：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        left=self.maxDepth(root.left)+!
        right=self.maxDepth(root.right)+1
        return max(left,right)

找出终止条件：当前节点为空
找出返回值：节点为空时说明高度为0，所以返回0；节点不为空时则分别求左右子树的高度的最大值，同时加1表示当前节点的高度，返回该数值

6.二叉树的最小深度

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left:
            return self.minDepth(root.right)+1
        if not root.right:
            return self.minDepth(root.left)+1
        left=self.minDepth(root.left)+1
        right=self.minDepth(root.right)+1
        return min(left,right)

这道题和maximum depth题正好相反，是求根节点到叶子节点的最小深度，为确保统计的是根节点到叶子节点的深度，需要注意：

• 当前节点左右子树有一个为空时，返回的应是非空子树的最小深度，而不是空子树深度0；若返回0相当于把当前节点认为成叶子节点，与此节点有非空子树矛盾。
• 当左右子树都不为空时，和maximum depth题一样，返回左右子树深度的最小值。
• 当左右子树都为空时，只有1个根节点深度为1（根节点与叶子节点重合）。

7.二叉树节点个数

迭代

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        
        if not root:
            return 0
        stack=[root]
        index=0
        while index<len(stack):
            if stack[index].left:
                stack.append(stack[index].left)
            if stack[index].right:
                stack.append(stack[index].right)
            index+=1
        
        return len(stack)

递归

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        return self.countNodes(root.left)+self.countNodes(root.right)+1

8.从前序与中序遍历序列构造二叉树(105)

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        def helper(p1,p2):
            if not p2:
                return None
            else:
                t=preorder.pop(0)
                T=TreeNode(t)
                i=p2.index(t)
                T1=helper(p1,p2[:i])
                T2=helper(p1,p2[i+1:])
                T.left=T1
                T.right=T2
                return T
        T=helper(preorder, inorder)
        return T