二叉树与递归

二叉树的递归遍历----以leetcode例题为例

树的递归遍历核心是：root节点做什么，孩子节点做相同的事情

一、入门简单

1、LeetCode94. 二叉树的中序遍历

左根右

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ans=[]
        def inorder(root):
            if root==None:
                return
            inorder(root.left)
            ans.append(root.val)
            inorder(root.right)
        inorder(root)
        return ans

二、中等难度

1、leetcode 226.翻转二叉树

 root节点：让左右节点翻转，孩子节点也翻转

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if(root==None):
            return None 
        tmp=root.left
        root.left=root.right
        root.right=tmp
        self.invertTree(root.left)
        self.invertTree(root.right)

        return root

2、leetcode 654.最大二叉树

 

 root 找到最大值为root值，最大值左边建造左儿子们，最大值右边建造右儿子们

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        if len(nums)==0:
            return None
        large=-1
        indx=-1
        
        for i in range(len(nums)):
            if nums[i]>large:
                large=nums[i]
                indx=i
        root = TreeNode(large)
        root.left=self.constructMaximumBinaryTree(nums[:indx])
        root.right=self.constructMaximumBinaryTree(nums[indx+1:])
        return root

3、leetcode 116.填充每个节点的下一个右侧节点指针

 root这里做的事什么

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if(root==None):
            return None
        self.connectAdjacent(root.left, root.right)
        return root

    def connectAdjacent(self, n1:'Node', n2:'Node')->'Node':
        if n1==None or n2 ==None:
            return 
        n1.next=n2
        self.connectAdjacent(n1.left, n1.right)
        self.connectAdjacent(n1.right,n2.left)
        self.connectAdjacent(n2.left,n2.right)

4、leetcode 114. 二叉树展开为链表

先序遍历，左子树的记录保存

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
       if(root==nullptr){
           return;
       }
       flatten(root->left);
       flatten(root->right);
       TreeNode* left=root->left;
       TreeNode* right=root->right;
       root->left=nullptr;
       root->right=left;

       TreeNode* p=root;
       while(p->right!=nullptr){
           p=p->right;
       }
       p->right=right;
    }
};

5、105. 从前序与中序遍历序列构造二叉树

对于root，根据前序遍历找出root的值，找出root的值在中序遍历中的位置，分段左右子树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        return self.build(preorder, 0, len(preorder)-1, inorder, 0, len(inorder)-1)
    def build(self, preorder, pStart, pEnd, inorder, iStart, iEnd):
        if (pStart>pEnd):
            return None
        root=TreeNode(preorder[pStart])
        indx=inorder.index(preorder[pStart])
        leftsize=indx-iStart
        root.left=self.build(preorder, pStart+1, pStart+leftsize, inorder, iStart, indx-1)
        root.right=self.build(preorder, pStart+leftsize+1, pEnd, inorder, indx+1, iEnd)
        return root

6、106. 从中序与后序遍历序列构造二叉树

 对于root，对比前面的前序和中序

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        return self.build(inorder,0, len(inorder)-1, postorder,0, len(postorder)-1)
    
    def build(self, inorder, istart, iend, postorder, pstart, pend):
        if istart>iend:
            return None
        root=TreeNode(postorder[pend])
        indx=inorder.index(postorder[pend])
        leftsize=indx-istart
        root.left=self.build(inorder, istart,indx-1, postorder,pstart,pstart+leftsize-1)
        root.right=self.build(inorder,indx+1, iend, postorder, pstart+leftsize, pend-1)
        return root

7、652. 寻找重复的子树

 对于每个节点，找出完整形状，并保存起来

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findDuplicateSubtrees(self, root: TreeNode) -> List[TreeNode]:
        memo=collections.Counter()
        res=[]
        self.traverse(root, memo,res)
        return res
    
    def traverse(self, root,memo,res):
        if(root==None):
            return '#'
        left=self.traverse(root.left,memo,res)
        right=self.traverse(root.right,memo,res)

        subTree=str(left)+','+str(right)+','+str(root.val)
        memo[subTree]+=1
        if memo[subTree]==2:
            res.append(root)
        return subTree