#230 Kth Smallest Element in a BST

最新推荐文章于 2022-08-12 12:05:29 发布

yoyooyooo

最新推荐文章于 2022-08-12 12:05:29 发布

阅读量1k

点赞数

分类专栏： leetcode 文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/YY_Tina/article/details/123464503

版权

二叉搜索树 kth最小值深度优先搜索广度优先搜索节点值查找

关键词由CSDN通过智能技术生成

leetcode 专栏收录该内容

188 篇文章 0 订阅

订阅专栏

Description

Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.

Examples

Example 1:
在这里插入图片描述

Input: root = [3,1,4,null,2], k = 1
Output: 1

Example 2:
在这里插入图片描述

Input: root = [5,3,6,2,4,null,null,1], k = 3
Output: 3

Constraints:

The number of nodes in the tree is n.
1 <= k <= n <= $10^4$
0 <= Node.val <= $10^4$

Follow up: If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?

思路

最开始的时候没有看到 “a binary search tree”，所以用的是广度优先搜索的方式，跑了一下看时间不对呀

后面看到了，直接按照深度优先搜索（左子树 - root - 右子树），找到第k小的数就行了（可以记一下深度优先搜索的非递归写法）

代码

非搜索树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int kthSmallest(TreeNode root, int k) {
        List<TreeNode> nodeList = new ArrayList<>();
        nodeList.add(root);
        List<Integer> route = new ArrayList<>();
        route.add(Integer.MAX_VALUE);
        
        while(nodeList.size() > 0){
            if (nodeList.get(0) == null){
                nodeList.remove(0);
                continue;
            }
            
            int curr = nodeList.get(0).val;
            int max_len = Math.min(route.size() - 1, k - 1);
            while(max_len >= 0 && route.get(max_len) > curr){
                max_len--;
            }

            route.add(max_len + 1, curr);
            
            nodeList.add(nodeList.get(0).left);
            nodeList.add(nodeList.get(0).right);
            nodeList.remove(0);
        }
        
        return route.get(k - 1);
    }
}

搜索树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int kthSmallest(TreeNode root, int k) {
        Stack<TreeNode> stack = new Stack<>();
        
        while (true) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            
            root = stack.pop();
            if (k == 1) {
                return root.val;
            }
            k--;
            
            root = root.right;
        }
    }
}