不带parent指针的successor求解

问题：

　　请设计一个算法，寻找二叉树中指定结点的下一个结点（即中序遍历的后继）。给定树的根结点指针TreeNode* root和结点的值int p，请返回值为p的结点的后继结点的值。保证结点的值大于等于零小于等于100000且没有重复值，若不存在后继返回-1。注意这里没有parent指针。

思路：

　　本质上还是二叉树的中序遍历。所以经过前面的学习我们有递归和非递归两种解法。

　　解法一(递归解法)：

public class Successor2 {
    public int findSucc(TreeNode root, int p) {
        if (root == null)
            return -1;
        in(root, p);
        return succ;
    }

    private void in(TreeNode<Integer> node, int p) {
        if (node == null)
            return;
        in(node.left, p);
        if (preValue == p) {
            if (succ != -1)
                return;
            succ = node.val;
            // System.out.println(succ);
            return;
        }
        preValue = node.val;
        in(node.right, p);
    }

    private int preValue = Integer.MIN_VALUE;
    private int succ = -1;

    public static void main(String[] args) {
        TreeNode root = buildTree(8, 6, 10);
        root.left.left = buildTree(3, 1, 4);
        root.right.right = buildTree(13, 11, 15);
        root.right.left = new TreeNode(9);

        final Successor2 tool = new Successor2();
        System.out.println(tool.findSucc(root, 8));  // 输出9
    }

    public static <T> TreeNode<T> buildTree(T rootValue, T lValue, T rValue) {
        TreeNode root = new TreeNode(rootValue);
        TreeNode left = new TreeNode(lValue);
        TreeNode right = new TreeNode(rValue);
        root.left = left;
        root.right = right;
        return root;
    }

    public static class TreeNode<T> {

        public T val;
        public TreeNode<T> left = null;
        public TreeNode<T> right = null;

        public TreeNode(T val) {
            this.val = val;
        }

    }
}

　　解法二(非递归解法)：

import java.util.Stack;

public class Successor1 {
    public int findSucc(TreeNode<Integer> root, int p) {
        if (root == null)
            return -1;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode curr = root;
        boolean isFound = false;
        // curr不为空或者栈不为空，都可以继续处理
        while (curr != null || !stack.isEmpty()) {// 没有生产也没有消费，就退出循环了
            // 左支路依次入栈
            while (curr != null) {
                stack.add(curr);
                curr = curr.left;
            }
            if (!stack.isEmpty()) {
                TreeNode<Integer> pop = stack.pop();// 栈的弹出顺序就是中序遍历的顺序
                // 上一轮修改了标志位，当前出栈的值就是我们需要的值
                if (isFound) {
                    return pop.val;
                }
                // 如果弹出值和p相同，那么下次弹出的值就是我们需要的值，修改标志位
                else if (pop.val == p) {
                    isFound = true;
                }
                // curr指向pop的右子树，继续外层循环
                curr = pop.right;// 有可能为空，为空，只消费栈中内容，不为空，就要向栈中生产若干内容
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        TreeNode<Integer> root = buildTree(1, 2, 3);
        root.left.left = buildTree(4, 5, 6);
        root.right.right = buildTree(7, 8, 9);

        System.out.println(new Successor1().findSucc(root, 3));  // 输出8
    }

    public static <T> TreeNode<T> buildTree(T rootValue, T lValue, T rValue) {
        TreeNode root = new TreeNode(rootValue);
        TreeNode left = new TreeNode(lValue);
        TreeNode right = new TreeNode(rValue);
        root.left = left;
        root.right = right;
        return root;
    }

    public static class TreeNode<T> {

        public T val;
        public TreeNode<T> left = null;
        public TreeNode<T> right = null;

        public TreeNode(T val) {
            this.val = val;
        }

    }
}