230.Kth Smallest Element in a BST

    /*
     * 230.Kth Smallest Element in a BST 
     * 2016-6-14 By Mingyang
     * 我的第一个想法就是这个题目肯定用dfs，然后我们可以用stack来做，也可以直接dfs来做
     * 后面又遇到改进型算法，不过时间都差不多
     */
    private static int number = 0;
    private static int county = 0;
    public int kthSmallest1(TreeNode root, int k) {
        county = k;
        dfs(root);
        return number;
    }
    public void dfs(TreeNode root) {
        if (root == null)
            return;
        dfs(root.left);
        county--;
        if (county == 0) {
            number = root.val;
            return;
        }
        dfs(root.right);
    }
    public int kthSmallest(TreeNode root, int k) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        int result = 0;
        // 不断的dfs，利用左中右的遍历方式进行遍历，然后依次取到最后的值
        while (!stack.isEmpty() || p != null) {
            if (p != null) {
                stack.push(p);
                p = p.left;
            } else {
                TreeNode t = stack.pop();
                k--;
                if (k == 0)
                    result = t.val;
                p = t.right;
            }
        }
        return result;
    }
    // 我的方法更快,利用左子树和右字数的个数的关系，如果k大于左子树的个数，那么就可以往右边走，这种方法复杂度T(n)=2T(n/2)+logn,也就是n
    //这里用了Binary Search的方法，根据count的大小来判断在哪个区间，然后去那个区间search，所以按理来说应该是logn，可是因为count用了n，所以总的时间就是n，哈哈！
    public int kthSmallest2(TreeNode root, int k) {
        int count = countNodes2(root.left);
        if (k <= count) {
            return kthSmallest2(root.left, k);
        } else if (k > count + 1) {
            return kthSmallest2(root.right, k-1-count); // 1 is counted as current node
        }
        return root.val;
    }
    public int countNodes2(TreeNode n) {
        if (n == null) return 0;
        return 1 + countNodes2(n.left) + countNodes2(n.right);
    }