Given a binary search tree, write a function kthSmallest
to find the kth 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:
void traverse(TreeNode* root, int k, int& i, int& val)
{
if(root == NULL || i > k)
{
return;
}
traverse(root -> left, k, i, val);
++ i;
if(i == k)
{
val = root -> val;
}
traverse(root -> right, k, i, val);
}
int kthSmallest(TreeNode* root, int k)
{
int i = 0;
int val = 0;
traverse(root, k, i, val);
return val;
}
};
/**
* 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:
void findK(TreeNode* root, int k, int& N, int& num)
{
if(root == NULL)
{
return;
}
findK(root -> left, k, N, num);
if(N >= k)
{
return;
}
++N;
if(N == k)
{
num = root -> val;
return;
}
findK(root -> right, k, N, num);
if(N >= k)
{
//num = root -> val;
return;
}
}
int kthSmallest(TreeNode* root, int k) {
int num = 0;
int N = 0;
findK(root, k, N, num);
return num;
}
};