【剑指offer】 面试题50： 树中两个结点的最低公共祖先

题目描述：

给定一棵树，同时给出树中的两个结点，求它们的最低公共祖先。

1 2 4 6 0 0 7 0 0 5 8 0 0 9 0 0 3 0 0
6 8

存在， 2

1 2 4 6 0 0 7 0 0 5 8 0 0 9 0 0 3 0 0
6 12

不存在

方法一：

后序遍历

 

基本思想：

1、两个节点不在一条线上（即两个节点不存在一个节点是另一个节点的祖先的情况），则它们必定分别在所求节点A的左子树和右子树上，

后序遍历到第一个满足这个条件的节点就是所要求的节点A。

2、当这两个节点在一条线上，所求节点A则是这两个节点中深度最低的节点的父节点。

package com.offer.chapter_7;

import java.util.Scanner;

class BinaryTreeNode {
	public int elem;
	public BinaryTreeNode left;
	public BinaryTreeNode right;
}

/**
 * @author hadoop
 * 
 * 求二叉树中任意两个节点的最近公共祖先也称为LCA问题（Lowest Common Ancestor）
 * 
 */
public class Interviews_50 {
	public static int curIndex = 0;
	
	public static BinaryTreeNode result = null;
	
	/**
	 * 
	 * 构建二叉树
	 * 
	 */
	public static void createBinaryTree(BinaryTreeNode curRoot, int[] data) {
		int leftElem = data[curIndex ++];
		
		if(leftElem == 0) {
			curRoot.left = null;
		} else {
			BinaryTreeNode leftChild = new BinaryTreeNode();
			leftChild.elem = leftElem;
			leftChild.left = leftChild.right = null;
			
			curRoot.left = leftChild;
			
			createBinaryTree(curRoot.left, data);
		}
		
		int rightElem = data[curIndex ++];
		
		if(rightElem == 0) {
			curRoot.right = null;
		} else {
			BinaryTreeNode rightChild = new BinaryTreeNode();
			rightChild.elem = rightElem;
			rightChild.left = rightChild.right = null;
			
			curRoot.right = rightChild;
			
			createBinaryTree(curRoot.right, data);
		}
	}
	
	/**
	 * 
	 * 基本思想：如果这两个节点不在一条线上（即这两个节点不存在一个节点是另一个节点的祖先的情况），则它们必定分别在所求节点A的左子树和右子树上，
	 * 后序遍历到第一个满足这个条件的节点就是所要求的节点A。否则，当这两个节点在一条线上，所求节点A则是这两个节点中深度最低的节点的父节点。
	 * 
	 * result 始终记录当前是否已经找到目标共同祖先结点
	 * 
	 */
	public static int findLowestCommonAncestor(BinaryTreeNode curRoot, int a, int b, BinaryTreeNode parent) {
		int left = 0;
		int right = 0;
		// 判断左子树是否含有要判断的两节点之一  
		if(result == null && curRoot.left != null) {
			left = findLowestCommonAncestor(curRoot.left, a, b, curRoot);
		}
		// 判断右子树是否含有要判断的两节点之一 
		if(result == null && curRoot.right != null) {
			right = findLowestCommonAncestor(curRoot.right, a, b , curRoot);
		}
		
		// 判断当前结点是否是所查找结点之一
		int mid = 0;
		if(curRoot.elem == a || curRoot.elem ==b) {
			mid = 1;
		}
		// 当前已经找到两个结点
		if(result == null && (left + right + mid) == 2) {
			// 如果两个结点在一条路径上,则当前结点的父节点为共同祖先结点
			if(mid == 1) {
				result = parent;
			} else {
				// 如果分别在当前结点的左右子树上，则当前结点为共同祖先结点
				result = curRoot;
			}
		}
		// 返回当前子树中包含查找结点的个数
		return (left + right + mid) > 0 ? 1 : 0;
	}
	
	/**
	 * 二叉树中任意两个节点的最近公共祖先
	 */
	public static void LowestCommonAncestor(BinaryTreeNode root, int a, int b) {
		result = null;
		
		if(root == null) {
			return;
		}
		
		findLowestCommonAncestor(root, a, b, null);
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int num = scanner.nextInt();

		while(num -- > 0) {
			BinaryTreeNode root = null;
			scanner.nextLine();
			String string = scanner.nextLine();
			String[] strs = string.split(" ");
			int[] data = new int[strs.length];
			
			int a = scanner.nextInt();
			int b = scanner.nextInt();
			
			for(int i=0; i<strs.length; i++) {
				data[i] = Integer.parseInt(strs[i]);
			}
			
			
			if(data.length < 2) {
				System.out.println("My God");
			} else {
				root = new BinaryTreeNode();
				root.elem = data[0];
				curIndex = 1;
				createBinaryTree(root, data);
				
				LowestCommonAncestor(root, a, b);
				
				if(result == null) {
					System.out.println("My God");
				} else {
					System.out.println(result.elem);
				}
			}
		}
	}
}