剑指offer面试题68 树中两个节点的最低公共祖先（java实现）

LCA(最近公共祖先)

1.树是二叉搜索树

package lca;
            
public class BinarySearchTree {
    public static void main(String args[]) {
        
        //放树节点的数组
        TreeNode<Integer> node[] = new TreeNode[7];
        
        //给节点赋值的数组
        int arr[] = {4,2,6,1,3,5,7};
        
        //处理引用关系
        //从0开始对节点编号的话，第i个节点的左子节点下标为2*i+1，右子节点为2*i+2
        for(int i=6;i>=0;i--) {
            node[i] = new TreeNode();
            node[i].value = arr[i];
            //不是叶子节点的话(叶子节点没有子节点)，把引用指向叶子节点
            if (i < node.length/2) {
                node[i].left = node[2 * i + 1];
                node[i].right = node[2 * i + 2];
            }
        }
        /*
                4
               /  \
              2    6
             / \  / \
            1   3 5  7
         */
        //找值为3的节点和值为5的节点的LCA
        TreeNode result = findLCA(node[4],node[5],node[0]);
        
        System.out.println(result);    
    }

    private static TreeNode findLCA(TreeNode node1, TreeNode node2, TreeNode current) {
        // TODO Auto-generated method stub
        //当前节点的值
        int value = (int) current.value;
        //比当前节点都小就到左子树中去找
        if(value > (int)node1.value && value > (int)node2.value ) {
            return findLCA(node1,node2,current.left);
        }
        //比当前节点都大就到左子树中去找
        if(value < (int)node1.value && value < (int)node2.value ) {
            return findLCA(node1,node2,current.right);
        }
        
        //否则就是当前节点
        //***二叉搜索树的定义是左子节点小于等于根节点，右子节点大于等于根节点。
        //***对于有值相等的情况也是输出当前节点,比如
        /*
               7
              / \
             7   8
        */
        
        return current;
    }

    
}

class TreeNode<T>{
    T value;
    TreeNode left;
    TreeNode right;
    @Override
    public String toString() {
        return "TreeNode [value=" + value + "]";
    }
    
}

2.树不是二叉树，但是有指向父节点的引用 ---- 转换为两个链表求公共节点

3.树不是二叉树，也没有指向父节点的引用。

思路 : 使用两个链表保存根节点到两个节点的路径，再求公共节点

package lca;

import java.util.Arrays;

//树结构定义
public class TreeNode1 {
    char value;
    TreeNode1 childs[];
    @Override
    public String toString() {
        return "TreeNode1 [value=" + value + "]";
    }
    
}

package lca;

import java.util.LinkedList;

public class WithoutParentNode {
    
    static final int maxNumOfChilds = 10;
    //使用两个链表来保存根节点到所求节点的路径
    static LinkedList list1 = new LinkedList();
    static LinkedList list2 = new LinkedList();
    
    public static void main(String args[]) {
        TreeNode1 A = new TreeNode1();
        A.value = 'A';
        TreeNode1 B = new TreeNode1();
        B.value = 'B';
        TreeNode1 C = new TreeNode1();
        C.value = 'C';
        TreeNode1 D = new TreeNode1();
        D.value = 'D';
        TreeNode1 E = new TreeNode1();
        E.value = 'E';
        TreeNode1 F = new TreeNode1();
        F.value = 'F';
        TreeNode1 G = new TreeNode1();
        G.value = 'G';
        TreeNode1 H = new TreeNode1();
        H.value = 'H';
        TreeNode1 I = new TreeNode1();
        I.value = 'I';
        TreeNode1 J = new TreeNode1();
        J.value = 'J';
        A.childs = new TreeNode1[] {B,C};
        B.childs = new TreeNode1[] {D,E};
        D.childs = new TreeNode1[] {F,G};
        E.childs = new TreeNode1[] {H,I,J};
        /*
                A
               / \ 
              B   C
             /  \ 
             D    E
           / \   / | \
          F   G  H I  J
         */
        
        //找F,H节点的LCA
        TreeNode1 lca = findLCA(F,H,A);
        System.out.println(lca);
    }
    
    
    private static TreeNode1 findLCA(TreeNode1 node1, TreeNode1 node2, TreeNode1 root) {
        // TODO Auto-generated method stub
        getPathFromRootToNode(node1,root,list1);
        getPathFromRootToNode(node2,root,list2);
        //list1 : D -- B -- A
        //list2 : E -- B -- A
        
        //接下来遍历两个链表找到最近的公共节点
        int index = 0;
        int length1 = list1.size();
        int length2 = list2.size();
        int sub = length1 > length2?length1-length2:length2-length1;
        if(length2 > length1) {
            LinkedList temp = list1;
            list1 = list2;
            list2 = temp;
        }
        while(index != length2-1) {
            if(((TreeNode1)list1.get(index+sub)).value == ((TreeNode1)list2.get(index)).value) {
                return (TreeNode1)list2.get(index);
            }else {
                index++;
            }
        }
        return null;
    }


    private static boolean getPathFromRootToNode(TreeNode1 node, TreeNode1 currentRoot, LinkedList list) {
        // TODO Auto-generated method stub
        
        //找到就直接返回true
        if(node.value == currentRoot.value) {
            return true;
        }
        
        //找不到就将当前节点加入路径,push是在链表的头插入的,offer是尾部
        list.push(currentRoot);
        
        boolean found = false;
        
        TreeNode1[] childs = currentRoot.childs;
        if (childs != null && childs.length > 0) {
            //遍历当前节点的所有子节点，在子节点里边找
            for (int i = 0; i < childs.length; i++) {
                if (found) {
                    break;
                } else {
                    found = getPathFromRootToNode(node, childs[i], list);
                }
            } 
        }
        //找不到就将当前节点从路径中删除,因为是递归，当递归回来到这里的时候，当前节点一定是list的最后一个节点，即栈顶
        if(!found) {
            list.pop();
        }
        
        return found;
    }
    
    
}