笔试刷题必备------ 树

笔试刷题必备------ 树

二叉树的最大深度

给定一个二叉树，找出其最大深度。

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

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

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

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def max_depth(self,root):
        if root == None:
            return 0
        return max(self.max_depth(root.left),self.max_depth(root.right))+1

if __name__ == "__main__":
    node1 = TreeNode(3)
    node2 = TreeNode(9)
    node3 = TreeNode(20)
    node4 = TreeNode(15)
    node5 = TreeNode(7)

    node1.left = node2
    node1.right = node3
    node3.left = node4
    node3.right = node5

    solu = Solution()
    print(solu.max_depth(node1))

验证二叉搜索树

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

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

方法1：中序遍历结果是有序的序列

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def is_valid_BST(self,root):
        res = self.inorder_traversal(root)
        return res == sorted(res)

    def inorder_traversal(self,root):
        if root == None:
            return []
        res = []
        res += self.inorder_traversal(root.left)
        res.append(root.val)
        res += self.inorder_traversal(root.right)

        return res

if __name__ == "__main__":
    node1 = TreeNode(2)
    node2 = TreeNode(1)
    node3 = TreeNode(4)
    node4 = TreeNode(3)
    node5 = TreeNode(6)

    node1.left = node2
    node1.right = node3
    node3.left = node4
    node3.right = node5

    solu = Solution()
    print(solu.is_valid_BST(node1))

方法2：递归法判断

#递归法直接判断
class Solution2(object):
    def is_valid_BST(self,root):
        min_val = max_val = None
        return self.recursive(root,min_val,max_val)

    def recursive(self,root,min_val,max_val):
        if root == None:
            return True
        if min_val is not None and root.val <= min_val:
            return False
        if max_val is not None and root.val >= max_val:
            return False

        if self.recursive(root.left,min_val,root.val) and self.recursive(root.right,root.val,max_val):
            return True
        else:
            return False

二叉树的层次遍历

class TreeNode(object):
	def __init__(self,x):
		self.val = x
		self.left = None
		self,right = None
class Solution(object):
	def level_order(self,root):
		if root == None:
			return []
		res = []
		level = [root]
		while level:
			res.append([node.val for node in level])
			temp = []
			for node in level:
				temp +=[node.left,node.right]
			level = [i for i in temp if i]
		return res

对称二叉树

class TreeNode(object):
	def __init__(self,x):
		self.val = x
		self.left = None
		self.right = None
class Solution(object):
	def isSymmetric(self, root):
		def is_same(p,q):
			if not p and not q:
				return True
			if p and q and p.val == q.val:
				l = is_same(p.left,q.right)
				r = is_same(p.right,q.left)
				return l and r
			else:
				return False
		if root == None:
			return True
		else:
			return is_same(root.left,root.right)

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

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def sortedArrayToBST(self,nums):
        if not nums:###注意！！！
        	return None
        if len(nums) == 1:
        	return TreeNode(nums[0])
        mid = len(nums)//2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

中序遍历二叉树

递归法：

class Solution(object):
	def in_order_recusive(self,root):
		if root == None:
			return []
		res = []
		res += self.in_order_recusive(root.left)
		res.append(root.val)
		res += self.in_order_recusive(root.right)
		return res

迭代法：

class Solution(object):
	def in_order_stack(self,root):
		if root == None:
			return []
		res = []
		temp  = root
		stack = []
		while temp or stack:
			if temp != None:
				stack.append(temp)
				temp = temp.left
			else:
				temp = stack.pop()
				res.append(temp.val)
				temp = temp.right
		return res

二叉搜索树中第K小的元素

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def kth_smallest(self,root,k):
        def in_order(root):
            if root == None:
                return []
            res = []
            res += in_order(root.left)
            res.append(root.val)
            res += in_order(root.right)
            return res
        order_list = in_order(root)
        if  k > len(order_list):
            return -1
        return order_list[k-1]




if __name__ == "__main__":
    node1 = TreeNode(2)
    node2 = TreeNode(1)
    node3 = TreeNode(4)
    node4 = TreeNode(3)
    node5 = TreeNode(6)

    node1.left = node2
    node1.right = node3
    node3.left = node4
    node3.right = node5

    solu = Solution()
    print(solu.kth_smallest(node1,6))

二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

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

  3
 / \
9  20
  /  \
 15   7

返回锯齿形层次遍历如下：

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

按层次遍历依次从左到右遍历每个根节点的左右节点，至于其中偶数层的逆序，借鉴其他博客的方法，用一个随层数奇偶变化的 数字1和-1来做标记。
在返回子列表时，先对标记做判断，如果为-1时，则将列表逆序输出即可

class Solution(object):
    def zigzagLevelOrder(self,root):
        if root == None:
            return []
        res = []
        tag = 1 #奇数层为1 偶数层为-1

        level = [root]
        while level:

            if tag == 1:
                cur = [node.val for node in level]
                res.append(cur)
                tag *= -1
            elif tag == -1:
                cur = [node.val for node in level]
                res.append(cur[::-1])
                tag *= -1
            temp = []
            for node in level:
                temp += [node.left,node.right]

            level = [i for i in temp if i]

        return res