二叉树最低公共祖先

在笔试中遇到了二叉树最低公共祖先的问题，现在将这个问题彻底地总结一下。其实相关问题还不少，比如二叉树是BST还是普通二叉树，二叉树存在指向父结点的指针吗？

1.二叉搜索树的情况，这样的情景下处理比较简单一些，前序遍历该二叉树，如果当前结点的值比两个所求结点大，则最低公共祖先肯定存在于当前结点的左子树中，如果当前结点的值比两个所求结点小，则最低公共祖先肯定存在于当前结点的右子树中，否则，当前结点即为所求LC.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        if(root != null)
            {
                if (root.val < p.val && root.val < q.val)
                    return lowestCommonAncestor(root.right,p,q);

                else if (root.val > p.val && root.val > q.val)
                    return lowestCommonAncestor(root.left,p,q);
                else
                    return root; 
            }
        return null;

    }
}

2.如果为普通二叉树且没有指向父结点的指针呢?如果可以使用辅助内存，可以把搜索所求结点的遍历路径保存下来，比如，放在ArrayList中，第一个相同结点即为LCA.如果不能使用辅助内存，就要使用难一点的递归求解了我。下面是整个过程的代码，可以在eclipse中单步运行查看过程，会理解得稍微深刻一些。

package com.leetcode.BinaryTree;

import java.util.ArrayList;
import java.util.Stack;

import com.nowcoder.TreeImp;

/** 
 * Created by yanglei 2017-3-22
 */
public class MyBinaryTree {
//    
    private TreeNode root=null;



    /*
     *
     */
    public MyBinaryTree(){
        root=new TreeNode(1,"root(3)");
    }

    /**
     * 
     *             
     */
    public void createBTree(){
        TreeNode newNode5=new TreeNode(2,"5");
        TreeNode newNode1=new TreeNode(3,"1");
        TreeNode newNode6=new TreeNode(4,"6");
        TreeNode newNode2=new TreeNode(5,"2");
        TreeNode newNode0=new TreeNode(6,"0");
        TreeNode newNode8=new TreeNode(7,"8");
        TreeNode newNode7=new TreeNode(8,"7");
        TreeNode newNode4=new TreeNode(9,"4");
        root.left=newNode5;
        root.right=newNode1;
        root.left.left=newNode6;
        root.left.right=newNode2;
        root.right.right=newNode8;
        root.right.left=newNode0;
        root.left.right.left=newNode7;
        root.left.right.right=newNode4;


    }

    public TreeNode getRoot(){
        return root;
    }
    public int getHeight(TreeNode subTree){
        return height(subTree);
    }

    private int height(TreeNode node) {
        if(node==null)
        return 0;
        else {
            int l=height(node.left);
            int r=height(node.right);
            return (l<r)?(r+1):(l+1);
        }
    }
   public int getSize(TreeNode subTree){
       return size(subTree);
   }
    private int size(TreeNode node) {
        if(node==null)
            return 0;
        else{
            return 1+size(node.left)
                    +size(node.right);
        }
    }

    /**
     * 
     * @param subTree
     * @param node
     * @return
     */
    public TreeNode getParent(TreeNode subTree,TreeNode node){
        if(subTree==null)
            return null;
        if(subTree.left==node || subTree.right==node)
            return  subTree;
        TreeNode p;

        if((p=getParent(subTree.left,node))!=null)
            return p;
        else
            return getParent(subTree.right,node);
    }

    public void preOrder(TreeNode subTree){
        if(subTree==null)
            return;
        else{
            visit(subTree);
            preOrder(subTree.left);
            preOrder(subTree.right);
        }
    }

    public void inOrder(TreeNode subTree){
        if(subTree==null)
            return;
        else{
            inOrder(subTree.left);
            visit(subTree);
            inOrder(subTree.right);
        }
    }

    public void postOrder(TreeNode subTree){
        if(subTree==null)
            return;
        else{
            postOrder(subTree.left);
            postOrder(subTree.right);
            visit(subTree);
        }
    }

    public void nonRecPreOrder(TreeNode subTree){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode p=subTree;
        while(p!=null||stack.size()>0){

            while(p!=null){
                visit(p);
                stack.push(p);
                p=p.left;
            }

            if(stack.size()>0){
                p=stack.pop();
                p=p.right;
            }
        }
    }

    public void nonRecInOrder(TreeNode subTree){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode p=subTree;
        while(p!=null || stack.size()>0){
            while(p!=null){
                stack.push(p);
                p=p.left;
            }
            if(stack.size()>0){
                p=stack.pop();
                visit(p);
                p=p.right;
            }
        }
    }

    public void nonRecPostOrder(TreeNode subTree){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode p=subTree;
        TreeNode node=null;
        while(p!=null){


            for(;p.left!=null;p=p.left)
                stack.push(p);

            while(p!=null&&p.right==null||p.right==node){
                visit(p);
//               
                node=p;
                if(stack.size()==0)
                    return;
//               
                p=stack.pop();
            }

            stack.push(p);

            p=p.right;
        }
    }


    /**
     * 
     * @param node
     */
    private void visit(TreeNode node){
        node.isVisited=true;
        System.out.println("NodeValue: "+node.data+",key="+node.key);
    }

    /**
     * 
     */
    private class TreeNode {
        public boolean isVisited=false;
        private String data="";
        public TreeNode left=null;
        public TreeNode right=null;
        private int key=0;
        private boolean rVisited=false;
        public TreeNode(int key,String data){
            this.key=key;
            this.data=data;
        }
    }


    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || p == null || q == null)
            return null;

        ArrayList<TreeNode> p_Path = new ArrayList<TreeNode>();
        ArrayList<TreeNode> q_Path = new ArrayList<TreeNode>();

        getPath(root,p,p_Path);
        getPath(root,q,q_Path);

        for (int i = 0;i < p_Path.size() && i < q_Path.size();i++)
        {
            if (p_Path.get(i).data == q_Path.get(i).data)
                return p_Path.get(i);
        }
        return null;


    }

    public Boolean getPath(TreeNode root2, TreeNode p, ArrayList<TreeNode> p_Path) {

        if (root2 == null || p == null)
            return null;

        if (root2 == p)
            return true;


        if (root2.left != null)
        {
            p_Path.add(root2.left);
            if (getPath(root2.left,p,p_Path))
                return true;
            p_Path.remove(p_Path.size() - 1);
        }

        if (root2.right != null)
        {
            p_Path.add(root2.right);
            if (getPath(root2.right,p,p_Path))
                return true;
            p_Path.remove(p_Path.size() - 1);
        }
        return false;   
        }



    /*

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        if(root == null || root == p || root == q) return root;

        TreeNode left = lowestCommonAncestor(root.left, p, q);

        TreeNode right = lowestCommonAncestor(root.right, p, q);

        if(left!=null&&right!=null) return root;

        return left == null ? right : left;
    }

    */

  public static void main(String[] args) 
 {
     MyBinaryTree mt = new MyBinaryTree();
     TreeNode root1 = mt.root;
     MyBinaryTree pq = new MyBinaryTree();
     mt.createBTree();
    // mt.preOrder(root1);
     TreeNode pTest = root1.left.left;
     TreeNode qTest = root1.left.right.left;
     TreeNode resultNode = mt.lowestCommonAncestor(root1, pTest, qTest);
     System.out.println(resultNode.data.toString());
 }
}