LeetCode 二叉树的层次遍历 II / 将有序数组转换为二叉搜索树 / 平衡二叉树 （9）

107. 二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

	    3
       / \
      9  20
         /  \
        15   7

返回其自底向上的层次遍历为：

[ [15, 7], [9, 20], [3] ]

# 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 levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        stack,res = [root],[]
        while stack:
            long = len(stack)
            i =0
            ans =[]
            while i < long:
                node = stack.pop(0)
                ans.append(node.val)
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
                i+=1
            res=[ans]+res
        return res
      

递归

# 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 _levelOrderBottom(self, level, result, node):
        if node:
            if level > len(result):
                result.insert(0,[])

            result[-level].append(node.val)
            self._levelOrderBottom(level+1, result, node.left)
            self._levelOrderBottom(level+1, result, node.right)

    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        level, result = 1, list()        
        self._levelOrderBottom(level, result, root)
        return result
       

108. 将有序数组转换为二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

# 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 sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        root, stack = None, [(0, len(nums)-1, None, None)]
        while stack:
            start, end, l_parent, r_parent = stack.pop()
            if start > end:
                continue
                
            mid = start + (end - start)//2
            node = TreeNode(nums[mid])
            root = root or node
            if l_parent:
                l_parent.right = node
                
            if r_parent:
                r_parent.left = node
                
            stack.append((start, mid-1, None, node))
            stack.append((mid+1, end, node, None))
            
        return root

递归

# 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 _sortedArrayToBST(self, nums, start, end):
        if start > end:
            return None
        
        mid = (end - start)//2 + start
        midNode = TreeNode(nums[mid])
        midNode.left = self._sortedArrayToBST(nums, start, mid - 1)
        midNode.right = self._sortedArrayToBST(nums, mid + 1, end)
        return midNode 
        
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        return self._sortedArrayToBST(nums, 0, len(nums) - 1)

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

		    3
	       / \
	      9  20
	        /  \
           15   7

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

	       1
	      / \
	     2   2
	    / \
       3   3
      / \
     4   4

返回 false 。

# 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 isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        stack = list()
        stack.append((root, 0))
        depths = {}
        while stack:
            node, seen = stack.pop()
            if node:
                if not seen:
                    stack.extend([(node, 1), (node.right, 0), (node.left, 0)])
                if abs(depths.get(node.left,0) - depths.get(node.right,0)) > 1:
                    return False
                depths[node] = max(depths.get(node.left,0), depths.get(node.right,0)) + 1

        return True

递归

# 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 isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def height(node):
            if not node:return 0
            left = height(node.left)
            right = height(node.right)
            if left == -1 or right == -1 or abs(left-right) > 1:
                return -1
            return max(left,right) + 1
        
        return height(root) != -1