LCA算法求任意两个节点之间的最小公共祖先（最短路径）

package com.mams.test;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by leixingbang on 2017/10/19.
 * Mail:leixingbang@qiyi.com
 */
public class TreeNode {
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof TreeNode)) return false;

        TreeNode treeNode = (TreeNode) o;

        if (!nodeName.equals(treeNode.nodeName)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        return nodeName.hashCode();
    }

    private String nodeName;
    private List<TreeNode>childLst;

    public TreeNode(String nodeName, List<TreeNode> childLst) {
        this.nodeName = nodeName;
        this.childLst = childLst;
    }

    public TreeNode(String nodeName) {
        this.nodeName = nodeName;
        this.childLst=new ArrayList<TreeNode>();
    }
    public void addNode(TreeNode node)
    {
        this.childLst.add(node);
    }

    public String getNodeName() {
        return nodeName;
    }

    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }

    public List<TreeNode> getChildLst() {
        return childLst;
    }

    public void setChildLst(List<TreeNode> childLst) {
        this.childLst = childLst;
    }



}

package com.mams.test;

import java.util.*;

/**
 * Created by leixingbang on 2017/10/20.
 * Mail:leixingbang@qiyi.com
 * 该工具用来遍历树所有节点，求最短路径
 */
public class TranvesalTreeNodeTool {
    //记录从根节点到某节点的路径，key为节点的名称，value为路径
    private HashMap<String, List<TreeNode>> pathMap = new HashMap<String, List<TreeNode>>();
    public void deepFirstSearch(TreeNode node) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<TreeNode> pathstack = new Stack<TreeNode>();
        stack.push(node);
        while (!stack.empty()) {
            TreeNode tempNode = stack.pop();
            vist(tempNode, pathstack);
            //说明该节点有孩子节点
            if (tempNode.getChildLst() != null && tempNode.getChildLst().size() > 0) {
                Iterator<TreeNode> iterator = tempNode.getChildLst().iterator();
                while (iterator.hasNext()) {
                    stack.push(iterator.next());
                }
            }
        }
    }

    public void vist(TreeNode node, Stack<TreeNode> pathStack) {
        //保证新加入pathStack的节点 必须是‘pathStack栈顶节点’的孩子节点
        while (pathStack.size() > 0 && !isChild(node, pathStack.peek())) {
            pathStack.pop();
        }
        pathStack.push(node);
        addPath(pathStack);
        //System.out.println("访问：" + node.getNodeName());
        if (isLeaf(node)) {
            //当遇到叶子节点时，打印从根节点到叶子节点的路径
            printPath(pathStack);
        }
    }

    public void addPath(Stack<TreeNode> pathStack) {
        TreeNode top = pathStack.peek();
        if (!this.pathMap.containsKey(top.getNodeName()))
            this.pathMap.put(top.getNodeName(), new ArrayList(pathStack));
    }

    public List<TreeNode> getRootToNodePath(String name) {
        return this.pathMap.get(name);
    }

    public static boolean isChild(TreeNode node, TreeNode nodeParent) {
        if (nodeParent.getChildLst() != null && nodeParent.getChildLst().size() > 0 && nodeParent.getChildLst().contains(node))
            return true;
        else
            return false;
    }

    /**
     * 打印路径
      * @param pathStack
     */
    public static void printPath(Stack<TreeNode> pathStack) {
        Iterator<TreeNode> iterator = pathStack.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next().getNodeName() + "->");
        }
        System.out.println();
    }
    /**
     * 打印路径
     * @param  pathLst
     */
    public static void printPath(List<TreeNode> pathLst) {
        Iterator<TreeNode> iterator = pathLst.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next().getNodeName() + "->");
        }
        System.out.println();
    }

    public static boolean isLeaf(TreeNode node) {
        if (node.getChildLst() == null || node.getChildLst().size() <= 0)
            return true;
        else
            return false;
    }

    /**
     * 由于一个孩子节点只有一个父节点，所以从根节点到某一节点的路径是单向且唯一的。如果两个节点有公共的祖先，两个路径合起来应该是倒立的Y字形，
     * 如A、B两个节点所示，从根节点开始遍历两条不同的路径，当路径出现不一致时(X节点)，出现不一致之前的那个点就是最小公共父亲节点
         *
         *
         X
        *  *
       *    *
      A      *
              *
               B
     *
     *
     * @param lst1
     * @param lst2
     * @return
     */
    public TreeNode getLeastParentNode(List<TreeNode> lst1, List<TreeNode> lst2) {

        List<TreeNode> loogerLst = lst2;
        List<TreeNode> shorterLst = lst1;
        if (loogerLst.size() < shorterLst.size()) {
            List<TreeNode> tempLst = loogerLst;
            loogerLst = shorterLst;
            shorterLst = tempLst;
        }
        int index = 0;
        for (int i = 0; i < shorterLst.size(); i++) {
            if (shorterLst.get(i).equals(loogerLst.get(i)))
                continue;
            else {
                index = i - 1;
                break;
            }
        }
        return shorterLst.get(index);


    }

    public static void main(String[] args) {
        TreeNode A = new TreeNode("A");
        TreeNode B = new TreeNode("B");
        TreeNode C = new TreeNode("C");
        TreeNode D = new TreeNode("D");
        TreeNode E = new TreeNode("E");
        TreeNode F = new TreeNode("F");
        TreeNode H = new TreeNode("H");
        A.addNode(B);
        A.addNode(C);
        B.addNode(D);
        B.addNode(E);
        C.addNode(F);
        D.addNode(H);
        TranvesalTreeNodeTool tranvesalTreeNodeTool = new TranvesalTreeNodeTool();
        tranvesalTreeNodeTool.deepFirstSearch(A);
        printPath(tranvesalTreeNodeTool.getRootToNodePath("E"));
        printPath(tranvesalTreeNodeTool.getRootToNodePath("H"));
        TreeNode x = tranvesalTreeNodeTool.getLeastParentNode(tranvesalTreeNodeTool.getRootToNodePath("E"), tranvesalTreeNodeTool.getRootToNodePath("H"));
        System.out.println(x.getNodeName());
    }
}