[剑指 Offer 54. 二叉搜索树的第k大节点] | 刷题打卡

今天我们来做一道LeetCode上的题目，原题链接：剑指 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 ≤ 二叉搜索树元素个数

思路分析

• 暴力方法
  • 循环遍历获取node.val存放至list，sort排序后取-k索引位置
• 中序遍历 + DFS
  • 深度递归中序遍历后取-k索引位置
• 中序遍历 + BFS
  • 广度中序遍历后取-k索引位置
• 逆中序遍历 + DFS
  • 深度递归逆中序遍历，每次递归k-=1，返回k==0是的node.val值
• 逆中序遍历 + BFS
  • 广度逆中序遍历，每次循环k-=1，返回k==0是的node.val值

代码

# Python
# 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 kthLargest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        # # 1.暴力方法
        # res = []
        # queue = [root]
        # while queue:
        #     node = queue.pop()
        #     res.append(node.val)
        #     if node.left: queue.append(node.left)
        #     if node.right: queue.append(node.right)
        # res.sort()
        # return res[-k]

        # # 2.中序遍历 + DFS
        # if not root: return 
        # res = []
        # def in_order(node):
        #     if not node: return
        #     in_order(node.left)
        #     res.append(node.val)
        #     in_order(node.right)
        # in_order(root)
        # return res[-k]


        # # 3.中序遍历 + BFS
        # if not root: return
        # stack, res = [], []
        # while root or stack:
        #     while root:
        #         stack.append(root)
        #         root = root.left
        #     root = stack.pop()
        #     res.append(root.val)
        #     root = root.right
        # return res[-k]

        # # 4.逆中序遍历 + DFS
        # if not root: return
        # self.k = k
        # def inverse_in_order(node):
        #     if not node: return
        #     l = inverse_in_order(node.right)
        #     self.k -= 1
        #     if self.k == 0: return node.val
        #     r = inverse_in_order(node.left)
        #     return l or r
        # return inverse_in_order(root)

        # 5.逆中序遍历 + BFS
        if not root: return
        stack = []
        while root or stack:
            while root:
                stack.append(root)
                root = root.right
            root = stack.pop()
            k -= 1
            if k == 0: return root.val
            root = root.left
        return 

总结

• 总共五种解决方案
• 推荐第3种和第5种

附录

• leetcode-cn.com/problems/er…

本文正在参与「掘金 2021 春招闯关活动」, 点击查看 活动详情