4 树

1 树的定义

树是递归定义的，所以和树相关的很多操作，用递归更容易实现。

2 树的遍历

采用python实现代码的原因是因为python语言本身较为简单，可以把时间和精力集中于思考真正的问题。

树的前序遍历

此题是leetcode的589题

前序遍历 前指的是根节点最先遍历。 满足同一父节点的孩子节点，左边的节点总是比右边的节点先遍历。 采用的数据结构为栈。 可以看到，在程序执行过程中，根节点的值会最先进入output。在每一个节点的子节点的进栈过程中，子节点需要逆序进栈，这样pop的时候就是顺序的，即满足同一父节点的孩子节点，左边的节点总是比右边的节点先遍历。

class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children
        
class Solution(object):
    def preorder(self, root):
        if root is None:
            return []
        stack, output = [root], []
        while stack:
            root = stack.pop()
            output.append(root.val)
            stack.extend(root.children[::-1])
        return output

树的后序遍历

此题是leetcode的590题
后序遍历 后指的是根节点最后遍历。 满足同一父节点的孩子节点，左边的节点总是比右边的节点先遍历。 采用的数据结构为栈。
可以看到在程序执行过程中，根节点的值会最先进入output, 那么为了让这个值最后输出，可以将output在返回时逆序。
那么在进栈的每一层的遍历过程中，子节点需要顺序进栈，这样pop的时候就是逆序的，output返回逆序后又会变成正的，即满足同一父节点的孩子节点，左边的节点总是比右边的节点先遍历。

class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children

class Solution(object):
    def postorder(self, root):
        if root is None:
            return []
        stack, output = [root], []
        
        while stack:
            root = stack.pop()
            output.append(root.val)
            stack.extend(root.children)
            
        return output[::-1]

递归实现

https://pintia.cn/problem-sets/15/problems/732

2.1.1 前序遍历

void PreorderTraversal( BinTree BT ){
    if (BT) {
        printf(" %c",BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}

2.1.2 中序遍历

void InorderTraversal( BinTree BT ){
    if (BT) {
        InorderTraversal(BT->Left);
        printf(" %c",BT->Data);
        InorderTraversal(BT->Right);
    }
}

2.1.3 后序遍历

void PostorderTraversal( BinTree BT ){
    if (BT) {
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        printf(" %c",BT->Data);
    }
}

2.1.4 层序遍历

void LevelorderTraversal( BinTree BT ){
    BinTree str[100], t;
    int rear = -1,front = -1;
    if (!BT) {
        return;
    }
    rear++;
    str[rear] = BT;
    
    while (rear != front) {
        front++;
        t = str[front];
        printf(" %c",t->Data);
        if (t->Left) {
            rear++;
            str[rear] = t->Left;
        }
        if (t->Right) {
            rear++;
            str[rear] = t->Right;
        }
    }
}

2.2 迭代实现

3 重建二叉树

3.1 已知前序遍历和中序遍历

此题是牛客网剑指offer第4题
二叉树的问题用递归都会简单些。前序遍历的第一个元素就是根节点。根据该节点在中序遍历中的位置，可以将前序遍历和中序遍历分为左子树和右子树。如此，递归即可求解。

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre) == 0:
            return None
        else:
            ans = TreeNode(pre[0])
            idx = tin.index(pre[0])
            ans.left = self.reConstructBinaryTree(pre[1:idx+1], tin[:idx])
            ans.right = self.reConstructBinaryTree(pre[idx+1:], tin[idx+1:])
            return ans

3.2 已知后序遍历和中序遍历

4 树的相关练习题

4.1 基础练习

4.1.1 牛客网树的子结构

class Solution:
    #判断 单个root的子树的程序
    def isSubtree(self, root1, root2):
        #如果2遍历完说明 匹配成功
        if root2 == None:
            return True
        #如果1便利完说明，2还没便利完，匹配不成功    
        if root1 == None:
            return False
        #如果这对根节点的值相等，进行相应的递归遍历这对节点的 左右节点是否匹配
        if root1.val == root2.val:
            return self.isSubtree(root1.left,root2.left) and self.isSubtree(root1.right,root2.right)
    #总程序
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        #特殊情况 需判断
        if pRoot1 == None or pRoot2 == None:
            return False
        #进行递归判断和遍历，判断1此时是否有2的子树，或1的左子树中是否存在与2相同的的子树，或1的右子树是否存在与2相同的子树
        return self.isSubtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)

4.1.2 牛客网二叉树的镜像

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        # 基准条件
        if root == None:
            return None
        # 将左右子树互换位置
        t = root.left
        root.left = root.right
        root.right = t
        # 递归每一个节点 将左右子树互换位置
        self.Mirror(root.left)
        self.Mirror(root.right)
        return root

4.1.3 牛客网从上往下打印二叉树

class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        queue = []
        # 
        if not root:
            return []
        result = []
        queue.append(root)
        while len(queue) > 0:
            currentRoot = queue.pop(0)
            result.append(currentRoot.val)
            if currentRoot.left:
                queue.append(currentRoot.left)
            if currentRoot.right:
                queue.append(currentRoot.right)
        return result

4.1.4 二叉树的后序遍历序列

知识点回顾：

二叉搜索树（Binary Search Tree，BST)又称二叉排序树、二叉查找树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

• 若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；
• 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
• 左、右子树也分别为二叉排序树；
  特点：左子树结点的值都小于根节点的值，右子树结点的值都大于根节点的值

后序遍历：先后序遍历左子树，再后序遍历右子树，最后访问根节点

思路：
后序遍历得到的序列，最后一个数是树的根节点的值 ，序列中最后一个数前面的数可以分为两部分：一部分是左子树节点的值，它们都比根节点的值小；第二部分是右子树节点的值，它们都比根节点的值要大。用递归的方法分别判断这两部分是否满足前面说得条件

# -*- coding:utf-8 -*-
# -*- coding:utf-8 -*-
class Solution:
    # 返回镜像树的根节点
    def VerifySquenceOfBST(self, sequence):
        if len(sequence) == 0:
            return False
        root = sequence[-1]
        # 左子树所有节点的值应该都小于root
        for i in range(len(sequence)):
            if sequence[i] > root:
                break
        # 右子树所有节点的值应该都大于root
        for j in range(i, len(sequence)):
            if sequence[j] < root:
                return False
        # 进入所有子树进行递归判断
        left = True
        if i > 0:
            left = self.VerifySquenceOfBST(sequence[0:i])
        right = True
        if i < len(sequence)-1 and left:
            right = self.VerifySquenceOfBST(sequence[i:-1])
        return right

4.1.5 二叉树中和为某一值的路径

思路：
可以按照深度优先遍历（DFS)来处理。创建一个空列表用来存放最终结果。从根节点开始，判断该节点的值与给定数值是否相等以及左、右子树是否为空。如果是，就把对应的值返回；如果不是，我们就分别对根节点的左子树、右子树进行递归。

# -*- coding:utf-8 -*-
class Solution:
    def FindPath(self, root, expectNumber):
        rst = []
        if not root:
            return []
        if not root.left and not root.right and root.val == expectNumber:
            return [[root.val]]
        else:
            left = self.FindPath(root.left, expectNumber - root.val)
            right = self.FindPath(root.right, expectNumber - root.val)
            for item in left + right:
                rst.append([root.val] + item)
            return rst