Cracking coding interview (4.5)二叉树按中序遍历次序返回某节点下一个节点

4.5 Write an algorithm to find the ‘next’ node (e.g., in-order successor) of a given

node in a binary search tree where each node has a link to its parent.

1.方法一:直接对二叉树进行中序遍历，获得中序遍历的节点列表，然后返回该列表中目标节点的下一个节点即可，该方法无需parent

2.方法二:根据目标节点target分情况:

1).若target.right != null,然会以target.right为树根的树的最左子孙节点

ELSE target.right == null

2).

2.1)若target == target.parent.left(target是他父亲的左孩子，则target的下一个节点就是

它的parent，值得注意的是若target的父节点为null，则target一定为root节点，它的next节点此时一定

为null).

2.2)若target == target.parent.right,回溯target，直到target的一个祖先X,且祖先X是他

父亲的左孩子，返回最先X的parent节点，反之target一直回溯一定会到root节点，此时返回null。

import java.util.ArrayList;
import java.util.Iterator;

class TreeNode{
int val;
TreeNode left;
TreeNode right;
TreeNode parent;
public TreeNode(int val){
this.val = val;
this.left = null;
this.right = null;
this.parent = null;
}
}

public class Solution{
//In-Order, gain the result list of In-Order
//then find the next node of target by traverse the result list
public static TreeNode findNextNode(TreeNode root, TreeNode target){
if(root == null)
return null;
ArrayList<TreeNode>	list =  new ArrayList<TreeNode>();
recurInOrder(root.left, list);
list.add(root);
recurInOrder(root.right, list);
//find next node
Iterator it = list.iterator();
//		System.out.println("list.size()="+list.size());//
int value = -1;
while(it.hasNext()){
value = ((TreeNode)it.next()).val;
System.out.print(value+" ");///
if(value == target.val){
System.out.println();///
if(it.hasNext())
return (TreeNode)it.next();
else
return null;
}
}
System.out.println();///
return null;
}
private static void recurInOrder(TreeNode tNode, ArrayList<TreeNode> list){
if(tNode != null){
recurInOrder(tNode.left, list);
list.add(tNode);
recurInOrder(tNode.right, list);
}
}
public static TreeNode getNextNodeInOrder(TreeNode target){
if(target == null)
return null;
TreeNode tNode = null;
if(target.right != null)
for(tNode = target.right;tNode.left != null;tNode = tNode.left)
;
else{
//target is left child
/*			if(target.parent == null || target == target.parent.left){
//actually when target.parent == null, target is root node
//only root node hasn't parent
tNode = target.parent;
// target is right child
}else{ */
//up util find a node which is left child of a parent
for(tNode = target;;)
if(tNode.parent == null || tNode == tNode.parent.left){
tNode = tNode.parent;
break;
}else
tNode = tNode.parent;
}

return tNode;
}

public static void main(String[] args){
TreeNode root = new TreeNode(0);
root.left = new TreeNode(1);
root.left.left = new TreeNode(3);
root.left.left.left = new TreeNode(7);
root.left.right = new TreeNode(4);
root.right = new TreeNode(2);
root.right.left = new TreeNode(5);
root.right.left.left = new TreeNode(8);
root.right.right = new TreeNode(6);

TreeNode tNode = Solution.findNextNode(root, new TreeNode(0));
System.out.println("R<0>:"+(tNode != null ? tNode.val : null));
tNode = Solution.findNextNode(root, new TreeNode(6));
System.out.println("R<6>:"+(tNode != null ? tNode.val : null));
tNode = Solution.findNextNode(root, new TreeNode(8));
System.out.println("R<8>:"+(tNode != null ? tNode.val : null));

root.parent = null;
root.left.parent = root.right.parent = root;
root.left.left.parent = root.left.right.parent = root.left;
root.left.left.left.parent = root.left.left;
root.right.left.parent =  root.right.right.parent = root.right;
root.right.left.left.parent =  root.right.left;

tNode = Solution.getNextNodeInOrder(root);
System.out.println("RR<0>:"+(tNode != null ? tNode.val : null));
tNode = Solution.getNextNodeInOrder(root.right.right);
System.out.println("RR<6>:"+(tNode != null ? tNode.val : null));
tNode = Solution.getNextNodeInOrder(root.right.left.left);
System.out.println("RR<8>:"+(tNode != null ? tNode.val : null));

}
}