Find下一个Node in BST

给定一个node，找inorder traversal 里下一个。

最直接的想法是inorder遍历整个bst，然后在遍历的结果中查找。但是这样耗费多余的空间和时间。

geeksforgeek

（1）有parent指针

在cc150上有很好的讲解

三种情况：

i 当前node的right ！= null, 则返回leftmost of right subtree

ii 当前node.right == null

 如果node为其parent的左孩子，则可以直接返回node.parent

如果node为其parent右孩子，则一直向上走直到node在parent left subtree

Node inorderSucc(Node n){
	if(n has a right subtree){
		return leftmost child of right subtree
	}else{
		while(n is a right child of n.parent){
			n = n.parent; // go up
		}
		return n.parent; // Parent has not been traversed
	}
}

　　实际代码：

public static TreeNode inorderNext(TreeNode node){
        if(node == null) return null;
        
        if(n.parent == null || node.right!= null){
            return leftMostChild(node.right);
        }else{

            TreeNode cur = node;
            TreeNode parent = cur.parent;  
            // Go up until we’re on left instead of right

            while(parent != null && parent.left != cur){
                cur = parent;
                parent = parent.parent;
            }
            return parent;
        }
    }
    public static TreeNode leftMostChild(TreeNode n) {
        if(n == null) {
            return null;
        }
        while(n.left!= null){
            n = n.left;
        }
        return n;
    }

 

 

 （2） 没有parent指针  http://www.geeksforgeeks.org/inorder-successor-in-binary-search-tree/

其实唯一不同的就是找parent或者gradparent那部分，这时候我们需要直到这棵树的root，从上向下遍历，记录parent

public TreeNode findSuccssor(TreeNode node, TreeNode root){
        
        if(node.right != null){
            return leftMostChild(node.right); 
        }
        TreeNode succ = null;
        //need to start from root, and search for successor down the tree
        while(root != null){
            if(root.val < node.val){
                //node if on right subtree
                
                root = root.right;
            }else if(root.val > node.val){
                //node is on left subtree
                succ = root;
                root = root.left;
            }else{
                //root.val == node.val;
                break;
            }
        }
        
        return succ;
    }