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

题目介绍

描述：

给定一棵二叉搜索树，请找出其中第k大的节点。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \\
 1   4
  \\
   2
输出: 4
示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \\
     3   6
    / \\
   2   4
  /
 1
输出: 4

限制：

1 ≤ k ≤ 二叉搜索树元素个数

解题思路：

递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果。

写树相关的算法，简单说就是，先搞清楚当前 root 节点该做什么，然后根据函数定义递归调用子节点，递归调用会让孩子节点做相同的事情。

二叉树题目的一个难点在于如何通过题目的要求思考出每一个节点需要做什么

二叉树解题策略

一递归二队列 + 迭代（层次遍历）三栈 + 迭代（非递归遍历）四其它

三种基本的遍历方式，都可以用递归来实现。写递归算法的时候，需要注意递归退出条件以及递归操作的表达。

二叉树的中序遍历是一个递增序列，所以中序遍历即可

自己的解法实现

def kthLargest(self, root, k):
        if not root: return 0
        self.res = []
        def helper(node):
            if not node: return
            helper(node.left)
            self.res.append(node.val)
            helper(node.right)
            return self.res
        helper(root)
        return self.res[::][-k]

网上比较优秀的解法

解法一

二叉搜索树的中序遍历为递增序列。二叉搜索树的中序遍历倒序为递减序列。求 “二叉搜索树第 kk 大的节点” 可转化为求 “此树的中序遍历倒序的第 kk 个节点”。

为求第 kk 个节点，需要实现以下三项工作：

递归遍历时计数，统计当前节点的序号；
递归到第 kk 个节点时，应记录结果 resres ；
记录结果后，后续的遍历即失去意义，应提前终止（即返回）。

def kthLargest2(self, root, k):
        def dfs(node):
            if not node: return
            dfs(node.right)
            self.k -= 1
            if self.k == 0:
                self.res = node.val
            dfs(node.left)

        self.k = k
        dfs(root)
        return self.res

解法二

中序遍历是升序数组。返回升序数组的倒数第k个节点，其下标为-k。

def kthLargest3(self, root, k):
        def inorder(node):
            if not node: return []
            return inorder(node.left) + [node.val] + inorder(node.right)

        return inorder(root)[-k]

解法三

二叉搜索树中，第1大到第len(nums-1)/2大一定位于右子树中，换句话说，如果k值满足：

1≤ k ≤len(nums−1)/2 则只遍历右子树就能找到第k大元素；

如果k值满足 k > len(nums-1) /2 才有必要去左子树中去查找；

def kthLargest4(self, root, k):
        self.count = k
        self.res = 0
        self.found = False    # 已经找到为True

        def travel(node):
            if not node or self.found: return

            # 遍历右子树
            travel(node.right)

            self.count -= 1
            if self.count == 0:
                self.res += node.val
                self.found = True
                return
            # 如果k > (len(nums)-1)/2，遍历左子树
            if not self.found:    # 没有找到再去左子树
                travel(node.left)
        travel(root)
        return self.res