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

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

一开始没注意到是搜索树，用set的自动排序特定得出结果，时间复杂度应该是O(nlogn)，总共n个节点，每次插入删除需要logn时间。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int kthLargest(TreeNode* root, int k) {
        if(!root) return 0;
        set<int,less<int>> s;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            TreeNode* temp=q.front();q.pop();
            if(s.size()<k)
                s.insert(temp->val);
            else{
                if(temp->val>*s.begin()){
                    s.erase(s.begin());
                    s.insert(temp->val);
                }
            }
            if(temp->left!=nullptr)
                q.push(temp->left);
            if(temp->right!=nullptr)
                q.push(temp->right);
        }
        return *s.begin();
    }

};

有二叉搜索树这个条件的话，因为二叉搜索树的中序遍历是递增序列，只要获取反向的递增序列就是从大到小了。

只用先保存下来k，然后再没经过一个节点递减k，如果减完之后就设置ans然后返回；如果减之前就是0，直接返回。其余情况正常递归。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    int ans;
    int k;
public:
    int kthLargest(TreeNode* root, int k) {
        this->k=k;
        dfs(root);
        return ans;
    }

    void dfs(TreeNode* curNode){
        if(curNode==nullptr)
            return ;
        dfs(curNode->right);
        if(k==0) return;
        if(--k==0){
            ans=curNode->val;
            return ;
        }
        dfs(curNode->left);
    }
};