Given a binary search tree, write a function kthSmallest
to find thekth smallest element in it.
Note:
You may assume k is always valid, 1 ≤ k ≤ BST's total elements.
Follow up:
What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine?
/**
* 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:
/*algorithm: BST in-order solution
1)in order BST
2)k is the kth element in order sequence
*/
bool inorder(TreeNode* root,int &cur,int k,int &val){
if(!root)return false;
if(inorder(root->left,cur,k,val))return true;
cur += 1;
if(cur == k){
val = root->val;
return true;
}
return inorder(root->right,cur,k,val);
}
int kthSmallest(TreeNode* root, int k) {
int cur = 0,val = INT_MIN;
inorder(root,cur,k,val);
return val;
}
};
class Solution {
public:
/*alorithm: count soluton
1)count left tree node,count is c
2)if c == k-1,root is the element we want
3)if c < k-1, k is in right child tree
4)if c >= k,k is in left child tree
*/
int countTree(TreeNode* root){
if(!root)return 0;
return 1 + countTree(root->left) + countTree(root->right);
}
int kthSmallest(TreeNode* root, int k) {
int l, r;
l = countTree(root->left);
if(l == k-1)return root->val;
if(l < k-1)return kthSmallest(root->right,k-l-1);
else return kthSmallest(root->left,k);
}
};