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));
}
}