剑指offer_2.3.4 树

参考：

1. 所有offer题目的LeetCode链接及python实现
2. github Target offer

2.3.4　树

1 树的遍历

分类一：

• 前序遍历：先访问根结点，再访问左子结点，最后访问右子结点。
• 中序遍历：先访问左子结点，再访问根结点，最后访问右子结点。
• 后序遍历：先访问左子结点，再访问右子结点，最后访问根结点。

分类二：

• 宽度优先遍历：先访问树的第一层结点，再访问树的第二层结点……一直到访问到最下面一层结点。
  • 在同一层结点中，以从左到右的顺序依次访问。
  • 可以对包括二叉树在内的所有树进行宽度优先遍历。

二叉树的特例：
1.二叉搜索树

• （左小根中右大），左子结点总是小于或等于根结点，而右子结点总是大于或等于根结点。
• 可以平均在 $O(logn)$的时间内根据数值在二叉搜索树中找到一个结点。

2.堆

• 在最大堆中根结点的值最大，在最小堆中根结点的值最小。

3.红黑树
红黑树是把树中的结点定义为红、黑两种颜色，并通过规则确保从根结点到叶结点的最长路径的长度不超过最短路径的两倍。

06.01 二叉树的镜像/反转

答案：https://leetcode.com/problems/invert-binary-tree/discuss/62714/3-4-lines-Python

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

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        ### 方法一：递归,最快
        # if not root:
        #     return root
        # root.left, root.right = root.right, root.left
        # if root.left:
        #     self.invertTree(root.left)
        # if root.right:
        #     self.invertTree(root.right)
        # return root
        ### 方法二：简易递归
        # if root:
        #     root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        # return root
        ### 方法三：使用stack实现, 最慢
        stack = [root]
        while stack:
            r = stack.pop()
            if r:
                r.left, r.right = r.right, r.left
                stack.extend([r.left, r.right])
        return root

06.02 重建二叉树（LeetCode 105）

题目：

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

思路解析

• 前序遍历的顺序为：根左右
• 中序遍历的顺序为：左根右

递归思想：

• 我们先根据前序遍历序列的第一个确定根，然后在中序遍历的序列中找到根的位置
• 根左边的就是其左子树，右边就是其右子树
• 构建根和左右子树
• 递归的进行上述步骤

技巧：根据根节点在 inorder 中的位置，找到左右子树的元素个数，从而找到左右子孙集合。

代码实现

方法一：

class Solution(object):
	def buildTree(self, preorder, inorder):
		if inorder:
			val = preorder.pop(0)
			idx = inorder.index(val)
			# 根据当前元素在inorder中的索引值，划分左右子树的中序遍历结果
			l_in = inorder[:idx]
			r_in = inorder[idx+1:]
			# 根据上一步找到的中序遍历的长度，划分左右子树的前序遍历结果
			l_pre = preorder[1:len(l_in)]
			r_pre = preorder[len(l_in)+1:]
			# 新建树节点空间，保存当前遍历到的元素
			root = TreeNode(val)
			# 递归调用方法
			root.left = self.buildTree(l_pre, l_in)
			root.right = self.buildTree(r_pre, r_in)
			return root

方法二：

class Solution(object):
    def buildTree(self, preorder, inorder):
        if inorder:
            ind = inorder.index(preorder.pop(0))
            root = TreeNode(inorder[ind])
            root.left = self.buildTree(preorder, inorder[0:ind])
            root.right = self.buildTree(preorder, inorder[ind+1:])
            return root

06.02 重建二叉树（LeetCode 106）

题目：

根据一棵树的中序遍历与后序遍历构造二叉树。
注意:你可以假设树中没有重复的元素。

思路解析

与前一题解法类似

代码实现

方法一：

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

class Solution(object):
    def buildTree(self, inorder, postorder):
        """
        :type inorder: List[int]
        :type postorder: List[int]
        :rtype: TreeNode
        """
        if postorder == []:
            return None
        # postorder中从后到前保存的是根节点的值
        val = postorder[-1]
        idx = inorder.index(val)

        left_in = inorder[:idx]
        right_in = inorder[idx+1:]

        left_post = postorder[:len(left_in)]
        right_post = postorder[len(left_in):-1]

        root = TreeNode(val)
        root.left = self.buildTree(left_in, left_post)
        root.right = self.buildTree(right_in, right_post)

        return root

方法二：
注意：

• 递归，先右子树，后左子树，因为需要对postorder从后到前弹出根节点元素
• pop()默认弹出最后一个元素，即后进先出原则

def buildTree(self, inorder, postorder):
    if inorder:
        ind = inorder.index(postorder.pop())
        root = TreeNode(inorder[ind])
        root.right = self.buildTree(inorder[ind+1:], postorder)
        root.left = self.buildTree(inorder[:ind], postorder)
        return root