Cracking the coding interview--Q4.6

原文：

Design an algorithm and write code to find the first common ancestor of two nodes in a binary tree. Avoid storing additional nodes in a data structure. NOTE: This is not necessarily a binary search tree.

译文：

写程序在一棵二叉树中找到两个结点的第一个共同祖先。不允许存储额外的结点。注意： 这里不特指二叉查找树。

若使用额外的存储空间，最简单的方式就是对于一个结点向父节点进行遍历，直至根结点。可以考虑存储为hash，然后对另一个结点向父节点进行遍历，同时和第一个结点的父节点，所组成的hash集合进行比较，第一个相同的结点即为二者的共同祖先；

若不能使用额外的存储空间，则只能是不断的取一个节点的父节点，然后同另外一个节点的所有父节点进行比较，直到根节点；

另外如果节点没有父指针，那么则需要从根节点开始遍历，依次判断每个节点，是否可以到达问题中的两个节点。找到最后一个这样的节点即可

代码如下：

1、如果结点可以记录父亲结点信息，并可以借助外部存储空间

/**
* @param p
* @param q
* @return
*
* 如果结点可以记录父亲结点信息，并可以借助外部存储空间，
* 则可以使p的所有父亲结点记录在hashset中，然后一次遍历q的父亲结点，每个父节点一次与hashset中的结点比较，
* 相同即为最近的相同父亲结点
*
*/
public static Node_4_6 findCommonParent(Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null) {
return null;
}
HashSet<Node_4_6> set = new HashSet<Node_4_6>();
while(p.parent != null) {
set.add(p.parent);
p = p.parent;
}
while(q.parent != null) {
q = q.parent;
if(set.contains(q)) {
break;
}
}
if(q != null) {
return q;
} else {
return null;
}
}

2、如果结点可以记录父亲结点信息，不可以借助外部存储空间

/**
* @param p
* @param q
* @return
*
* 如果结点可以记录父亲结点信息，不可以借助外部存储空间，
* 则可以遍历p的所有父亲结点，然后每次遍历一个p的父亲结点则依次遍历q的父亲结点，直到找到相同结点存在，
* 相同即为最近的相同父亲结点
*
*/
public static Node_4_6 findCommonParent2(Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null) {
return null;
}
while(p.parent != null) {
p = p.parent;
while(q.parent != null) {
q = q.parent;
if( p == q) {
return p;
}
}
}
return null;
}

3、如果结点没有引用父亲结点，并且同时不能使用额外的存储空间

/**
* @param head
* @param p
* @param q
* @return
*
* 如果结点没有引用父亲结点，并且同时不能使用额外的存储空间，
* 则只能从head结点一次遍历结点信息，并且每次遍历结点判断当前结点是否同时为p,q的父结点
* 并且还需要判断是否最近
*
*/
public static void findCommonParent3(Node_4_6 head, Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null || head == null) {
return;
}
if(head != null && head!=p && head!=q && father(head, p) && father(head, q)) {
ancestor = head;
findCommonParent3(head.lchild, p, q);
findCommonParent3(head.rchild, p, q);
}
}

/**
* @param head
* @param node
* @return
*
* 判断当前结点node是否是head结点的子节点
* 即head是否为node的祖先结点
*
*/
public static boolean father(Node_4_6 head, Node_4_6 node) {
if(head == null) {
return false;
} else if(node == head) {
return true;
} else {
return father(head.lchild, node) || father(head.rchild, node);
}
}

总代码如下：

package chapter_4_TreesandGraphs;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Stack;

class Node_4_6 {
public int data;
public Node_4_6 lchild;
public Node_4_6 rchild;
public Node_4_6 parent;
}

public class Question_4_6 {
private static Node_4_6 p, q;
private static Node_4_6 ancestor;

public static void insertTreeNode(Node_4_6 curNode, Node_4_6 node) {
if(node.data < curNode.data) {
if(curNode.lchild != null) {
insertTreeNode(curNode.lchild, node);
} else{
curNode.lchild = node;
node.parent = curNode;
}
} else {
if(curNode.rchild != null) {
insertTreeNode(curNode.rchild, node);
} else {
curNode.rchild = node;
node.parent = curNode;
}
}
}

public static void createTree(Node_4_6 head, int array[]) {
int len = array.length;
int curIndex = 1;
while(curIndex < len) {
Node_4_6 node = new Node_4_6();
node.data = array[curIndex];
if(node.data == 1) {
p = node;
System.out.println("set p.data = " + node.data);
}
if(node.data == 5) {
q = node;
System.out.println("set q.data = " + node.data);
}
node.lchild = null;
node.rchild = null;
insertTreeNode(head, node);
curIndex ++;
}
}

public static void postOrderTraverce(Node_4_6 head) {
Stack<Node_4_6> stack = new Stack<Node_4_6>();
stack.push(head);
Node_4_6 node;
Node_4_6 preNode = null;
while(!stack.empty()) {
node = stack.peek();
if(node.lchild==null && node.rchild==null ||
(preNode!=null && (node.lchild == preNode || node.rchild == preNode))) {
System.out.print(" " + node.data + " ");
stack.pop();
preNode = node;
} else {
if(node.rchild != null) {

4000
stack.push(node.rchild);
}
if(node.lchild != null) {
stack.push(node.lchild);
}
}
}
}

/**
* @param p
* @param q
* @return
*
* 如果结点可以记录父亲结点信息，并可以借助外部存储空间，
* 则可以使p的所有父亲结点记录在hashset中，然后一次遍历q的父亲结点，每个父节点一次与hashset中的结点比较，
* 相同即为最近的相同父亲结点
*
*/
public static Node_4_6 findCommonParent(Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null) {
return null;
}
HashSet<Node_4_6> set = new HashSet<Node_4_6>();
while(p.parent != null) {
set.add(p.parent);
p = p.parent;
}
while(q.parent != null) {
q = q.parent;
if(set.contains(q)) {
break;
}
}
if(q != null) {
return q;
} else {
return null;
}
}

/**
* @param p
* @param q
* @return
*
* 如果结点可以记录父亲结点信息，不可以借助外部存储空间，
* 则可以遍历p的所有父亲结点，然后每次遍历一个p的父亲结点则依次遍历q的父亲结点，直到找到相同结点存在，
* 相同即为最近的相同父亲结点
*
*/
public static Node_4_6 findCommonParent2(Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null) {
return null;
}
while(p.parent != null) {
p = p.parent;
while(q.parent != null) {
q = q.parent;
if( p == q) {
return p;
}
}
}
return null;
}

/**
* @param head
* @param p
* @param q
* @return
*
* 如果结点没有引用父亲结点，并且同时不能使用额外的存储空间，
* 则只能从head结点一次遍历结点信息，并且每次遍历结点判断当前结点是否同时为p,q的父结点
* 并且还需要判断是否最近
*
*/
public static void findCommonParent3(Node_4_6 head, Node_4_6 p, Node_4_6 q) {
if(p ==null || q ==null || head == null) {
return;
}
if(head != null && head!=p && head!=q && father(head, p) && father(head, q)) {
ancestor = head;
findCommonParent3(head.lchild, p, q);
findCommonParent3(head.rchild, p, q);
}
}

/**
* @param head
* @param node
* @return
*
* 判断当前结点node是否是head结点的子节点
* 即head是否为node的祖先结点
*
*/
public static boolean father(Node_4_6 head, Node_4_6 node) {
if(head == null) {
return false;
} else if(node == head) {
return true;
} else {
return father(head.lchild, node) || father(head.rchild, node);
}
}

public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
// 7 10 1 3 6 5 4 2 8
String strs[] = string.split(" ");
int array[] = new int[strs.length];
for(int i=0; i<array.length; i++) {
array[i] = Integer.parseInt(strs[i]);
}

Node_4_6 head = new Node_4_6();
head.data = array[0];
head.lchild = null;
head.rchild = null;

createTree(head, array);

postOrderTraverce(head);
System.out.println("");

Node_4_6 commonParent = findCommonParent(p, q);
if(commonParent == null) {
System.out.println("error!不存在");
} else {
System.out.println("common least parent is : " + commonParent.data);
}

Node_4_6 commonParent2 = findCommonParent2(p, q);
if(commonParent2 == null) {
System.out.println("error!不存在");
} else {
System.out.println("common least parent is : " + commonParent.data);
}

findCommonParent3(head, p, q);
if(ancestor == null) {
System.out.println("error!不存在");
} else {
System.out.println("common least parent is : " + ancestor.data);
}

}
}