劍指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;
    }
    
    
}