找二叉树的中序后继

设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。

如果指定节点没有对应的“下一个”节点，则返回null。

方法一：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<TreeNode> list = new ArrayList();
    int pos = -1;
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        inorderVisit(root,p);
        if(pos!=-1){
            if((pos+1)<=(list.size()-1)){
                return list.get(pos+1);
            }
        }
        return null;
    }

    public void inorderVisit(TreeNode root, TreeNode p) {
        if(root!=null){
            if(root.left!=null){
                inorderSuccessor(root.left,p);
            }
             list.add(root);
            if(root.val == p.val){
               pos=list.size()-1;
            }
            if(root.right!=null){
                inorderSuccessor(root.right,p);
            }
        }
    }
}

执行结果：通过

显示详情

执行用时：4 ms, 在所有 Java 提交中击败了35.04%的用户

内存消耗：39.5 MB, 在所有 Java 提交中击败了51.87%的用户

方法一：解决了问题，遍历了整棵树，如果我们需要的后继节点位于比较靠前的位置，就很大程度上有资源浪费，所以运行结果来看，效率和内存消耗都不低。

方法二：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<TreeNode> list = new ArrayList();
    int pos = -1;
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        inorderVisit(root,p);
        if(pos!=-1){
            if((pos+1)<=(list.size()-1)){
                return list.get(pos+1);
            }
        }
        return null;
    }

    public void inorderVisit(TreeNode root, TreeNode p) {
        if(root!=null){
            if(root.left!=null){
                inorderSuccessor(root.left,p);
            }
            list.add(root);
            
            if(root.val == p.val){
               pos=list.size()-1;
            }
            if(pos!=-1&&list.size()>(pos+1)){
                   return;
            }
            if(root.right!=null){
                inorderSuccessor(root.right,p);
            }
        }
    }
}

执行结果：通过

显示详情

执行用时：3 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：39.4 MB, 在所有 Java 提交中击败了64.60%的用户

方法二：方法二在方法一的基础上，新增了一条规则，如果找到了后继节点就停止对树的遍历，从运行结果看，运行效率显著提高。

方法三：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    TreeNode result = null;
    boolean flag = false;
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        inorderVisit(root,p);
        if(result!=null){
            return result;
        }
        return null;
    }

    public void inorderVisit(TreeNode root, TreeNode p) {
        if(root!=null){
            if(root.left!=null){
                inorderSuccessor(root.left,p);
            }
            if(flag&&result==null){
                result = root;
                return;
            }
            if(root.val == p.val){
               flag = true;
            }
            
            if(root.right!=null){
                inorderSuccessor(root.right,p);
            }
          
        }
    }
}

执行结果：通过

显示详情

执行用时：3 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：38.9 MB, 在所有 Java 提交中击败了97.06%的用户

方法三：方法三在存储上作了优化，全局只存储一个节点，目标节点的后继，对于无用节点一律不存

通过这个题的解答过程可以发现，在解决问题的时候，合理的利用存储结构将会带来很大的性能提升优化