剑指54.二叉搜索树的第 k 大节点,55.二叉树深度

54.二叉搜索树的第 k 大节点

中序遍历：left→root→right的顺序递归，得到的结果是升序
采用right→root→left的方式，得到降序，存在list中，最后取第k个元素
改进：提前停止递归（剪枝）
每次递归
traverse(right)之后
记录步数，当到达k时，表示这是第k大节点，停止递归

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        self.k=k
        def helper(root):
        	##停止条件：root=None或到达指定步数##
            if not root or self.k==0:return
            helper(root.right)
            ##遍历一次后记录步数，若到达指定步数，储存该节点的值##
            self.k-=1
            if self.k==0:self.res=root.val
            helper(root.left)
        helper(root)
        return self.res

55.二叉树深度

1.Depth-First-Search（DFS）

常用的DFS，前中后序遍历
本题后序遍历
树的最大深度=max(左子树深度，右子树深度)+1
采用递归
递归停止条件，节点为None，返回深度0
时间复杂度O(N)要遍历所有结点
最差空间复杂度O(N)当所有结点只有一棵子树时，为链表

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None:return 0
        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1

2.Breadth First Search（BFS）

层序遍历：
创建一个队列queue来存储每一层的节点，用一个变量res来记录第几层，如果queue为空，return res
用另外一个temp来存下一次层的结点，然后更新queue,清空temp，res+=1

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:return 0
        que=[root]
        dep=0
        while que:
            tem=[]
            dep+=1
            for i in que:
                if i.left:tem.append(i.left)
                if i.right:tem.append(i.right)
            que=tem
        return dep

55-II 平衡二叉树

1.自顶向下

判断root节点是否平衡：|左子树深度-右子树深度|<=1&左子树平衡&右子树平衡
注意要分别判断左右子树平衡
通过height函数计算树得深度（时间复杂度O（n））
最差情况需要遍历所有节点，总时间复杂度O(n2)

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root):
            if not root:return 0
            return max(height(root.left),height(root.right))+1
        if not root:return True
        return abs(height(root.right)-height(root.left))<=1 and self.isBalanced(root.right) and self.isBalanced(root.left)

2.自底向上遍历（后序遍历）

从最底左右子树向上判断是否平衡，若不平衡返回-1，平衡返回树得高度
自上向下判断左右子树高度差是否大于1

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root):
            if root is None:return 0
            h_left=height(root.left)
            h_right=height(root.right)
            if h_left==-1 or h_right==-1 or abs(h_right-h_left)>1:return -1
            return max(h_left,h_right)+1
        return height(root)!=-1

对每个节点只进行一次height计算，时间复杂度O(n)空间复杂度O(n)