LeetCode Python实现 二叉树简单部分

LeetCode Python实现 二叉树简单部分
'''
1
二叉树的最大深度
给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
 给定二叉树 [3,9,20,null,null,15,7]，
    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。
'''

#方法1 
# 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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def depth(p):
            if p == None:
                return 1
            else:
                return 1 + max(depth(p.right), depth(p.left))

        if root == None:
            return 0
        else:
            return max(depth(root.right), depth(root.left))


#方法2没有通过

# 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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0
        else:
            return 1 + max(maxDepth(root.right), maxDepth(root.left)) #NameError: global name 'maxDepth' is not defined


'''
2
验证二叉搜索树
给定一个二叉树，判断其是否是一个有效的二叉搜索树。

一个二叉搜索树具有如下特征：
•节点的左子树只包含小于当前节点的数。
•节点的右子树只包含大于当前节点的数。
•所有左子树和右子树自身必须也是二叉搜索树。

示例 1:
输入:
    2
   / \
  1   3
输出: true


示例 2:
输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。
'''
#方法1
# 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 isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def get(root):
            if root == None:
                return [0,0]
            if root.left != None:
                small = get(root.left)[0]
            else:
                small = root.val
            if root.right != None:
                big = get(root.right)[1]
            else:
                big = root.val
            return [small,big]
        if root == None:
            return True
        if root.left != None and get(root.left)[1] >= root.val:
            return False
        if root.right != None and get(root.right)[0] <= root.val:
            return False
        if self.isValidBST(root.left) and self.isValidBST(root.right):
            return True
        return False


#方法2
"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""
class Solution:
    """
    @param root: The root of binary tree.
    @return: True if the binary tree is BST, or false
    """  
    def isValidBST(self, root):

        if root is None:
            return True
        if root.left is None and root.right is None:
            return True

        if root.left:
            if not self.isValidBST(root.left):
                return False
            elif self.max_val(root.left) >= root.val:
                return False
            
        if root.right:
            if not self.isValidBST(root.right):
                return False
            elif self.min_val(root.right) <= root.val:
                return False

        return True

    def min_val(self, root):
        result = root.val
        while root.left:
             result = root.left.val
             root = root.left
        return result

    def max_val(self, root):
        result = root.val
        while root.right:
             result = root.right.val
             root = root.right
        return result
        # write your code here

'''
3
对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
    1
   / \
  2   2
 / \ / \
3  4 4  3


但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
    1
   / \
  2   2
   \   \
   3    3


说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。


'''
#方法1
# 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 isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def help(p, q):
            if p == None and q == None:
                return True
            if p and q and p.val == q.val:
                return help(p.left, q.right) and help(p.right, q.left)
            return False
        
        if root:
            return help(root.left, root.right)
        return True
#方法2
# Definition for a  binary tree node
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    # @param root, a tree node
    # @return a boolean
    def isSymmetric(self, root):
        if root:
            return self.help(root.left, root.right)
        return True
        
    def help(self, p,q):
        if p is None and q is None: return True
        if p and q and p.val == q.val:
            return self.help(p.left, q.right) and self.help(p.right, q.left)
        return False

方法3
class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def f(p, q):
            if p == None:
                return q == None
            if q == None:
                return p == None
            if p.val == q.val:
                return f(p.left, q.right) and f(p.right, q.left)
            if p.val != q.val:
                return False
        if root == None:
            return True
        return f(root.left, root.right)

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

class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        #思路主要参考leetcode100题，这里将根节点的左右节点假设成两颗独立的树，这样解题跟100就是类似的了,区别：递归调用时，因是对称，所以是左树左节点与右树右节点，左树右节点与右树左节点
        #先定义，后调用
        def isSameTree(p,q):
            if not p and not q:#两二叉树皆为空，递归边界，两者皆为空返回真  
                return True  
            if p and q and p.val==q.val:  
                l=isSameTree(p.left,q.right)#，与leetcode100有区别。递归，每次重新从函数入口处进行，每次进行递归边界判断  
                r=isSameTree(p.right,q.left)  
                return l and r#and操作，需要l与r皆为true时，才返回真。只用最后一次递归边界return值  
            else:  
                return False
        if not root:
            return True
        else:
            #p=root.left;q=root.right
            return isSameTree(root.left,root.right)
        


'''
4
二叉树的层次遍历
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

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


返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

[Leetcode] Binary tree level order traversal二叉树层次遍历
'''
#方法1：
# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        ans = []
        def bfs(root,level):
            if root != None:
                if len(ans) < level + 1:
                    ans.append([])
                ans[level].append(root.val)
                bfs(root.left,level+1)
                bfs(root.right,level+1)
        bfs(root,0)
        return ans

#方法2
# 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 preorder(self, root, level, res):
        if root:
            if len(res) < level + 1: res.append([])
            res[level].append(root.val)
            self.preorder(root.left, level + 1, res)
            self.preorder(root.right, level + 1, res)
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        self.preorder(root, 0, res)
        print res
        return res
方法3：BFS。层序遍历的一般想法，做广度优先遍历（BFS）。遍历的同时，注意记录遍历结果要用满足题目要求的输出格式
# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        if root == None:
            return res

        q = [root]
        while len(q) != 0:
            res.append([node.val for node in q])
            new_q = []
            for node in q:
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)
            q = new_q

        return res
方法4：DFS用深度优先搜索（DFS），节点的深度与输出结果数组的下标相对应。注意在递归的时候要保存每次访问的节点值。
# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        self.dfs(root, 0, res)
        return res

    def dfs(self, root, depth, res):
        if root == None:
            return res
        if len(res) < depth+1:
            res.append([])
        res[depth].append(root.val)
        self.dfs(root.left, depth+1, res)
        self.dfs(root.right, depth+1, res)

'''
5
将有序数组转换为二叉搜索树

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

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

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

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

      0
     / \
   -3   9
   /   /
 -10  5


题目意思：将排序后的数组转换成二叉查找树。

二叉查找树的定义：

（1）若它的左子树不空，则其左子树上任意结点的关键字的值都小于根节点关键字的值。

（2）若它的右子树不空，则其右子树上任意结点的关键字的值都大于根节点关键字的值。

（3）它的左、右子树本身又是一个二叉查找树。

Description：已知一个按升序排列的数组，将它转换为一个高度平衡二叉树。其中，平衡二叉树（AVL树）被定义为其左子树和右子树都是高度平衡的二叉树，且左子树和右子树的高度之差的绝对值不超过1。




解题思路：因为给定的数组是按照升序排列的，所以可以先取出数组中间位置的值作为二叉查找树的根结点，然后以该数组中间位置的值为中心，将左边的数组划分到根结点的左子树中，右边的数组划分到根结点的右子树中，这样就能保证根结点的左子树上任意结点的值都小于根结点的值，右子树上任意结点的值大于根节点的值。接下来，可以使用递归地方法继续取出左边数组的中间值作为根结点的左子结点，右边数组的中间值作为根结点的右子结点，然后以左边数组中间值为中心，再次划分左右子树，右边数组同理，如此递归下去，对于每个结点，总是能保证其左子树上任意结点的值都要小于该节点的值，其右子树上任意结点的值都要大于该节点的值。
'''
#方法1
# 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
        """
        #递归方法
        if not nums:
            return None
        mid=len(nums)//2#找到中间节点
        root=TreeNode(nums[mid])#当前节点为根节点
        root.left=self.sortedArrayToBST(nums[:mid])#小于当前根节点的作为左子树
        root.right=self.sortedArrayToBST(nums[mid+1:])#大于当前根节点的作为右子树
        return root
#方法2
解题思路：由于要求二叉查找树是平衡的。所以我们可以选在数组的中间那个数当树根root，然后这个数左边的数组为左子树，
右边的数组为右子树，分别递归产生左右子树就可以了。

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

class Solution:
    # @param num, a list of integers
    # @return a tree node
    def sortedArrayToBST(self, num):
        length = len(num)
        if length == 0:
            return None
        if length == 1:
            return TreeNode(num[0])
        root = TreeNode(num[length / 2])
        root.left = self.sortedArrayToBST(num[:length/2])
        root.right = self.sortedArrayToBST(num[length/2 + 1:])
        return root
方法2.2
题目思路：

　　将中位数为根节点，中位数左边为左子树，右边为右子树。
# 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
        """
        size = len(nums)
        if size == 0:
            return None
        if size == 1:
            return TreeNode(nums[0])
        size //= 2
        root = TreeNode(nums[size])
        root.left = self.sortedArrayToBST(nums[:size])
        root.right = self.sortedArrayToBST(nums[size + 1:])
        return root