230. Kth Smallest Element in a BST

题目：

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?

Hint:

1. Try to utilize the property of a BST.
2. What if you could modify the BST node's structure?
3. The optimal runtime complexity is O(height of BST).

题意：

给定一个二叉搜索树，写一个功能kthSmallest用来找到该二叉树中第K小的元素。

二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。即根节点的值是中间值，左子树的值均小于根节点的值，右子树的值均大于根节点的值。

note：

可以假设k总是有效的，1 ≤ k ≤二叉搜索树总的节点数量。

Follow up：

如果BST的修改（插入/删除）操作十分频繁，并且需要频繁地找出第k小的元素，应该怎样优化kthSmallest函数？

Hint:

1、尝试利用BST的属性。

2、如果你可以修改BST节点的结构时，应该怎样做？

3、最优时间复杂度应该是O(BST的高度)。

思路一：

利用堆栈实现，利用堆栈实现中序遍历，首先找到最左边的元素，即为该二叉搜索树的最小值，将从根节点开始的所有左子树的根节点都保存在堆栈中，以备左右子树切换时使用，每找到一个左子树叶子节点，则k减一，病切换到右子树去查询，直到k为0为止，返回该节点的值即可。非递归版。

代码：java版：2ms

/** * Definition for a binary tree node. * public class TreeNode { *     int val; *     TreeNode left; *     TreeNode right; *     TreeNode(int x) { val = x; } * } */public class Solution {    public int kthSmallest(TreeNode root, int k) {        Stack<TreeNode> stack = new Stack<TreeNode>();        TreeNode node = root;        while (node.left != null) { //将所有的左子树入栈            stack.push(node);            node = node.left;        }                while (k>0 && (node!=null || !stack.isEmpty())) {            if (node == null) {  //如果节点为空                node = stack.pop();  //找到其父节点                if (--k == 0) //找到第k小的元素                    return node.val;                node = node.right;  //找右子树            } else {                  stack.push(node);                node = node.left;            }        }        return node.val;    }}

代码：C++版：20ms

/** * 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 kthSmallest(TreeNode* root, int k) {        int cnt = 0;        stack<TreeNode*> s;        TreeNode *p = root;        while (p || !s.empty()) {            while (p) {                s.push(p);                p = p->left;            }            p = s.top();            s.pop();            ++cnt;            if (cnt == k)                return p->val;            p = p->right;        }        return 0;    }};

思路二：

利用计算二叉树节点数量的子函数，计算出根节点左子树的总的节点数量，然后比较左子树节点数量与k值得大小，如果k值小于左子树节点数目，则说明该值在左子树中，继续对左子树进行迭代处理，如果大于，则说明k值最小的节点在右子树中，则对右子树进行迭代处理，并且减掉前面左子树数目的k值。

代码：C++版：24ms

/** * 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 kthSmallest(TreeNode* root, int k) {        if (root == NULL) return 0;                int leftSize = treeSize(root->left);        if (k == leftSize+1) {            return root->val;        } else if (leftSize >= k) {            return kthSmallest(root->left, k);        } else {            return kthSmallest(root->right, k-leftSize-1);        }    }        int treeSize(TreeNode* root) {  //计算根节点下有多少节点        if (root == NULL) return 0;        return 1 + treeSize(root->left) + treeSize(root->right);    }};

思路三：

直接递归实现,依然基于中序遍历的思想。

代码：C++版：20ms

/** * 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 kthSmallest(TreeNode* root, int k) {        return kthSmallestDFS(root, k);    }    int kthSmallestDFS(TreeNode* root, int &k) {        if (!root) return -1;        int val = kthSmallestDFS(root->left, k);        if (!k)            return val;        if (!--k)             return root->val;        return kthSmallestDFS(root->right, k);    }};