b树的构造c++_刷题-树的相关计算

链表弄的有点明白后，我就想对树也速成一下。树一般都是迭代，我总是搞不清逻辑，不知道迭代终止条件咋写，以及，迭代中间的计算到底咋实现的。今天打算就补补树的逻辑。

1.计算树的高度

这是一棵树：

正常情况下按照咱们大脑的想法：

• 1）算 A 的左右子树高度，返回他俩中 最大的那个数，加上1返回。
• 2）算 A 的 左子树高度，算 A 的右子树高度。
• 3）A 的左子树 B 的高度 --> B 的左右子树高度，返回他俩中 最大的那个数，加上1
• A 的右子树 C 的高度 --> C 的左右子树高度，返回他俩中 最大的那个数，加上1
• 4）算 B 的左子树高度，算 B 的右子树高度
• 算 C 的左子树高度，算 C 的右子树高度
• 5）..........
• n）一直算到叶子节点的左子树右子树为空的情况，那么叶子节点的右子树左子树的高度应该为 0，叶子节点的高度就是max(0,0)+1=1。

发现1）的结果依赖于2），2）的结果依赖于3），n-1）的结果依赖于 n），而只有到n）的时候才能算出实际值，推出n-1），....，1）。然后返回1）的结果，算出整个树的高度。

其实这就是个迭代过程，整个过程中，需要明确的是：

• 迭代关系：某个节点的高度 = max( leftHeight, rightHeight)+1
• 迭代终止条件即能求出实际值的最小单元(叶子节点的左右节点)：if node==null: return 0

所以求一颗树的高度的代码就出来了：

题目来源：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0 # 迭代最小单元/终止条件
        return max(maxDepth(root.right),maxDepth(root.left))+1 #迭代关系

2.判断是否是平衡二叉树

平衡二叉树：平衡二叉树一般指平衡树。平衡树(Balance Tree，BT) 指的是，任意节点的左右子树的高度差都小于等于1。

题目：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

解读：判断是否是平衡二叉树的本质也是求解树的高度问题，只不过最后需要比较下是不是深度不超过1。

正常情况下按照咱们大脑的想法：

• 1）判断节点 A 是否满足条件，分别计算 A 的左右子树高度，计算他俩之间的差值的绝对值，如果>1，return False。
• 2）计算 B 的高度，并判断节点 B 是否满足条件。
• 满足条件，返回heightB，不满足，返回一个特定标签代表不满足条件
• 计算 C 的高度，并判断节点 C 是否满足条件。
• 满足条件，返回heightC，不满足，返回一个特定标签代表不满足条件
• 3）..........
• n）一直算到叶子节点的左子树右子树为空的情况，那么叶子节点的右子树左子树的高度应该为 0，叶子节点满足平衡二叉树节点的要求，返回叶子节点的高度 1。

----------------------先吃饭，今天中午笋尖酸辣粉。好吧，其实我并不饿，甚至还想吐。
我回来啦---------------------------

所以上面这个过程的：

• 迭代关系：满足条件，返回heightB，不满足，返回一个特定标签代表不满足条件
• 迭代终止条件：if node==null: return 0

我们把特定标签设置为-1，因为如果满足条件返回高度的话一定>=0的。
代码如下：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(node):
            if not node: return 0 #迭代 终止条件（可计算最小单位）
            heightR = height(node.right) #计算右子树高度
            if heightR == -1: return -1 #如果右子树的根节点不满足条件直接返回-1

            heightL = height(node.left) #计算左子树高度
            if heightL == -1: return -1 #如果左子树的根节点不满足条件直接返回-1
            
            # 判断当前节点是否满足条件，满足返回高度，不满足返回-1
            if abs(heightR-heightL)<=1: return max(heightL,heightR)+1
            else: return -1
        return height(root)!=-1

其实这道题的变形就是在计算高度时加了个条件，如果节点满足某种条件我再返回真实高度，如果不满足，返回特定标签。

其实这两个题，发现没，计算高度，都是自底向上的。

3.根据树的前序遍历和中序遍历结果重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

题目链接： 重建二叉树_牛客网

思路：前序遍历的第一位 1 是根节点，找到中序遍历中的1，那么 1 左边的是左子树的内容，右边的是右子树的内容。所以每次取出根节点，然后把左右子树分好去迭代就行。

• 终止条件/可求解的最小单元：前序遍历里没有数据了，遍历完全，返回节点None
• 迭代关系：
  root.right = recur(right_pre, right_tin)
  root.right = recur(right_pre, right_tin)
  每次返回 root即可

代码：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        if not pre: return None #终止条件，可求解最小单元
        root = TreeNode(pre[0])
        root_index = tin.index(root.val)
        pre_left,pre_right = pre[1:1+root_index],pre[1+root_index:]
        tin_left,tin_right = tin[:root_index],tin[root_index+1:]
        root.left = self.reConstructBinaryTree(pre_left,tin_left)
        root.right = self.reConstructBinaryTree(pre_right, tin_right)
        return root

也是，自底向上的建立二叉树，所以每次返回的root，是从叶子节点一点一点向上返回的，所以最终返回的root就是根节点。

4.输出二叉树的镜像树

题目：操作给定的二叉树，将其变换为源二叉树的镜像。

链接：二叉树的镜像_牛客网

这个比上面那个前序和中序遍历结果重建树还要简单，因为不需要找根节点在哪，不需要判断左右子树部分的数据。依旧迭代。

• 终止条件/可求解的最小单元：前序遍历里没有数据了，遍历完全，返回节点None
• 迭代关系：
  new_root.right = recur(root.left)
  new_root.left = recur(root.right)
  每次返回 new_root 即可

于是我开始写出了这样的代码，看起来是如此的美好：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if not root: return None
        mi_root = TreeNode(root.val)
        mi_root.left = self.Mirror(root.right)
        mi_root.right = self.Mirror(root.left)
        return mi_root

但是可是当他运行起来，是酱婶儿的：

那这样，我就很难受了啊。哎，桥豆麻袋，我的结果里实际输出=用例输出？？？难道是想要原地改变吗？？？我是新开辟了空间耶。于是我改了改：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if not root: return None
        temp = self.Mirror(root.left)
        root.left = self.Mirror(root.right)
        root.right = temp
        return root

结果ac了，不要问我：

• 为什么没有mi_root = TreeNode(root.val)类似的那一步赋值根节点的操作了？
  因为，原地修改啊，他的根节点数值就是他自己，再赋值不是画蛇添足嘛。
• 为什么要有个temp？
  因为，没有temp，root.left的值就被覆盖了，获取不到了啊

总结：好好的题目，为什么 就不强调下需要原地修改。害。我不管上面非原地修改的我也验证不了，我就默认是没有问题的。

5.二叉树的前中后序遍历

哈哈哈哈这个过程有点搞笑，事情是这样的，我本来想做下面这道题的，结果突然发现自己get了前中后序遍历的结果，笑死。过程如下：

题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。
题目链接：从上往下打印二叉树_牛客网

这题就有点意思，我一看这不简单嘛，不就是个迭代遍历，打印吗？那我肯定迭代中print啊，于是，我写出了这样的代码：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self,root):
        # write code here
        if not root: return None
        print(root.val)
        self.PrintFromTopToBottom(root.left)
        self.PrintFromTopToBottom(root.right)

多切合题意啊，题目中要求：

• 从上到下 --> 我直接拿到root，就print(root.val)
• 从左到右 --> 我先加左节点，再加右节点
• 打印二叉树 --> 我print

看起来是不是有理有据，都要切合题目切合的都感动了呢。我就美滋滋的去运行了。结果：害，天不随人愿啊。我不明白啊，我真的不明白啊，因为牛客网总没有示例，我就跑去leetcode搜了搜同题，因为都是剑指offer上的题，两个网站上都有，于是，我在leetcode上看到的题目是这样的：

这，好像要求返回list？而不是我认为的诚实的打印print？？？哈哈哈想哭，然后我又看到leetcode给的代码框架，这样的：

人家直接表明了需要返回的类型啊，这多直接了当啊。害，牛客网你学学要不？？？

于是我改了改代码，找个全局变量res存一下数据，再返回：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def __init__(self):
        self.res = []
    def PrintFromTopToBottom(self,root):
        # write code here
        self.recur(root)
        return self.res
    
    def recur(self,root):
        if not root: return None
        self.res.append(root.val)
        self.recur(root.left)
        self.recur(root.right)

结果是这样的：

咦，为啥不对呢？我思考了片刻，我这个先左子树再右子树貌似是 前序遍历的结果？？？emmm，所以我一直求的是前序遍历耶，，，有没有前序遍历的题让我验证一下，我随手搜了一下，然后吧，还真有：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/submissions/

结果就通了呢，真emmm无心插柳？？？

所以。。。我竟然会写前序遍历的代码了。。那中序呢，题目链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/submissions/

只要recur和append调个顺序就可以了吧，先迭代左子树，再加入根节点，代码这样婶儿：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def __init__(self):
        self.res = []
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        self.recur(root)
        return self.res

    def recur(self,root):
        if not root: return None
        self.recur(root.left) #左子树
        self.res.append(root.val) #根节点
        self.recur(root.right) #右子树

emmm过了，我可真是个机灵鬼，那么后序遍历？？https://leetcode-cn.com/problems/binary-tree-postorder-traversal/submissions/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def __init__(self):
        self.res = []
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        self.recur(root)
        return self.res

    def recur(self,root):
        if not root: return None
        self.recur(root.left) #左子树
        self.recur(root.right) #右子树
        self.res.append(root.val) #根节点

emmm过了，哈哈哈哈这是个什么操作啊，笑死我了。所以我会写前中后序遍历结果了。。然后我又突然看到leetcode的一个温馨提示：

emmm我开始思考，我好像并不知道他俩有啥区别，我甚至以为他俩是一个。于是，搜搜呗，得到：

• 迭代：利用变量的原值推出新值称为迭代，或着说迭代是函数内某段代码实现循环；
• 递归：重复调用函数自身实现循环称为递归；
• 两者关系：所有的迭代可以转换为递归，但递归不一定可以转换成迭代。

吼吼吼，所以我上面的都是递归，不能叫迭代哦，我都是函数调用自己实现的，哈哈哈为什么不把上面的改一下呢，并不是因为我懒，我只是想把这个过程体现出来，真的不是因为我懒，不是因为我懒，重要的事情说三遍。

所以，这个前中后序遍历，要如何通过迭代来实现呢？这道题我会哈哈哈哈。

前序遍历，我上来就这么写了（注意下面是错误的）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        res, q = [], [root]
        while q:
            temp = q.pop(0)
            if temp:
                res.append(temp.val)
                if temp.left: q.append(temp.left)
                if temp.right: q.append(temp.right)      
        return res

每次取root列表q的第一项值，先加根节点，然后加左节点，然后右节点。看起来完美。运行-->报错，fine。呵呵，果然没让我失望。举个例子为什么这么操作会错，针对下面这个树，根据上面的代码，其运行流程是：

所以，最终输出是[A,B,C,D,E,F,G,H]，但是其正确的前序输出是：[A,B,D,C,E,F,G,H]
问题出在哪里呢？就看D和C的顺序，按照先序遍历的规则的话，D是A的左子树，那肯定在C之前，但是我的代码，因为C先加入的，所以先把C拿出来了，所以不对。那么怎么改呢？下面这个代码就是先加右子树，pop出q的最后一个，就很神奇就过了，我一下子没反应过来，再走个流程看看：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

流程如下，发现最终输出的res就正确了。

应该猜得出来，我已经混乱了现在。即使流程都出来了，我还是没能准确的反应出来，区别在哪里。我在等大佬指点。。我先去干点别的吧。。

大佬指点：

• pop(0) 是实现了队列的功能（先进先出）
• pop() 是实现了栈的功能（后进先出）
• 先右后左，pop() 可以确保左子树的某个节点被弹出分析后，加入的下一个节点还是左子树的子节点。（啊啊啊我这说什么，这一条不要看）

反正记住用栈就是对了！！！然后分析一下栈的后进先出特点，就知道先进哪个了！

所以，让我们用迭代的方法写一下中序遍历：

............写不出来.......瞄一眼别人的，人家写的可真好看啊。七个小时前发布。还热乎：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/jie-yong-zhan-shi-xian-er-cha-shu-de-zhong-xu-bian/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        stack, ans = [],[]
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            ans.append(root.val)
            root = root.right
        return ans

至于读懂代码思路，官方题解链接这个迭代图示挺好的：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/er-cha-shu-de-zhong-xu-bian-li-by-leetcode/

我估计，我还是写不出来下次........

那么后序遍历呢....leetcode上的难度标识是hard....https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

和前序遍历代码就很像：（脑细胞不够用了都）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    #迭代
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        q,res = [root],[]
        while q:
            s = q.pop()
            res.append(s.val)
            if s.left: q.append(s.left)
            if s.right: q.append(s.right)
        return res[::-1]

见到我记得喊我写二叉树的前中后遍历迭代写法代码，我脑子现在罢工了已经。我需要休息。