树的一些操作

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import java.util.Vector;

public class TreeOperator {
    public static void preOrder(TreeNode node) {
        if (node != null) {
            System.out.print(node.data + " ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    public static void BFSTreeNode(TreeNode node) {
        if (node == null) {
            System.out.println("TreeNode is null");
        }
        LinkedList<TreeNode> linkedList = new LinkedList<TreeNode>();
        linkedList.push(node);
        while (!linkedList.isEmpty()) {
            TreeNode n = linkedList.removeFirst();
            System.out.print(n.data + " ");
            if (n.left != null) {
                linkedList.add(n.left);
            }
            if (n.right != null) {
                linkedList.add(n.right);
            }
        }
        System.out.println();
    }

    public static int getTreeNodeDepth(TreeNode node) {
        if (node == null)
            return 0;
        return 1 + Math.max(getTreeNodeDepth(node.left),
                getTreeNodeDepth(node.right));
    }

    public static boolean IsBalanced(TreeNode node) {
        boolean res = true;
        if (node == null) {
            return res;
        }
        int leftdepth = getTreeNodeDepth(node.left);
        int rightdepth = getTreeNodeDepth(node.right);
        if (Math.abs(leftdepth - rightdepth) > 1)
            return false;
        return IsBalanced(node.left) && IsBalanced(node.right);
    }

    // 判断是否是子树
    /**
     * @param root
     * @param node
     *            子树
     * @return
     */
    public static boolean isSubTreeNode(TreeNode root, TreeNode node) {
        if ((root == null && node != null) || (root != null && node == null)) {
            return false;
        }
        if (root == null && node == null) {
            return true;
        }
        return isSubTreeNodeCore(root, node);
    }

    public static boolean isSubTreeNodeCore(TreeNode root, TreeNode node) {
        boolean result = false;
        if (root.data == node.data) {
            result = checkAllNodes(root, node);
        }
        if (!result && root.left != null) {
            result = isSubTreeNodeCore(root.left, node);
        }
        if (!result && root.right != null) {
            result = isSubTreeNodeCore(root.right, node);
        }
        return result;
    }

    public static boolean checkAllNodes(TreeNode root, TreeNode node) {
        if (node == null)
            return true;
        if (root == null)
            return false;
        if (root.data == node.data) {
            return checkAllNodes(root.left, node.left)
                    && checkAllNodes(root.right, node.right);
        } else {
            return false;
        }
    }

    public static void printByLayer(TreeNode node) {
        if (node == null) {
            System.out.println("TreeNode is null");
        }
        Vector<TreeNode> vector = new Vector<TreeNode>();
        LinkedList<TreeNode> linkedList = new LinkedList<TreeNode>();
        linkedList.add(node);
        vector.add(node);
        int start = 0;
        int end = vector.size();
        while (start < vector.size()) {
            while (start < end) {
                node = vector.get(start);
                System.out.print(vector.get(start).data + " ");
                start++;
                if (node.left != null)
                    vector.add(node.left);
                if (node.right != null)
                    vector.add(node.right);
            }
            end = vector.size();
            System.out.println();
        }
    }

    // 打印从根到每个叶子的路径
    public static void getAllPath(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        getAllPath(root, stack);
    }

    public static void getAllPath(TreeNode root, Stack s) {
        if (root != null)
            s.push(root);
        if (root.left == null && root.right == null) {
            Iterator<TreeNode> it = s.iterator();
            while (it.hasNext()) {
                System.out.print(it.next().data + " ");
            }
            System.out.println();
        }
        if (root.left != null) {
            getAllPath(root.left, s);
        }
        if (root.right != null) {
            getAllPath(root.right, s);
        }
        s.pop();
    }

    public static List getNodePath(TreeNode root, TreeNode node) {
        List list = new ArrayList<TreeNode>();
        getNodePath(root, node, list);
        return list;
    }
    public static void getNodePath(TreeNode root, TreeNode node,
            List<TreeNode> list) {
        if (root != null)
            list.add(root);
        if (root == node) {
            for (TreeNode n : list) {
                System.out.print(n.data + " ");
            }
            System.out.println();
        }
        if (root!=null&&hasNode(root.left, node) == true) {
            getNodePath(root.left, node, list);
        }
        if (root!=null&&hasNode(root.right, node) == true) {
            getNodePath(root.right, node, list);
        }
    }
    public static boolean hasNode(TreeNode root, TreeNode node) {
        if (root == node) {
            return true;
        }
        boolean lefthas = false;
        boolean righthas = false;
        if (root!=null&&root.left != null) {
            lefthas = hasNode(root.left, node);
        }
        if (root!=null&&lefthas == false && root.right != null) {
            righthas = hasNode(root.right, node);
        }
        return lefthas || righthas;
    }
    public static TreeNode getCommonParent(TreeNode root,TreeNode node1 ,TreeNode node2){
        TreeNode commonParent=null;
        List<TreeNode> listnode1=getNodePath(root,node1);
        List<TreeNode> listnode2=getNodePath(root,node2);
        int len1=listnode1.size();
        int len2=listnode2.size();
        int len=len1>len2?len1:len2;
        int i=0;
        for(;i<len1&&i<len2;i++){
            if(listnode1.get(i).data!=listnode2.get(i).data){
                break;
            }
        }
        if(i-1>0){
            commonParent =listnode1.get(i-1);
        }else if(i==1&&listnode1.get(0).data==listnode2.get(0).data){
            commonParent=listnode1.get(0);
        }
        return commonParent;
    }
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode t1 = new TreeNode(8);
        TreeNode t2 = new TreeNode(7);
        TreeNode t3 = new TreeNode(9);
        TreeNode t4 = new TreeNode(2);
        TreeNode t5 = new TreeNode(4);
        TreeNode t6 = new TreeNode(7);
        root.left = t1;
        root.right = t2;
        t1.left = t3;
        t1.right = t4;
        t4.left = t5;
        t4.right = t6;
        preOrder(root);
        System.out.println();
        int depth = getTreeNodeDepth(root);
        System.out.println(depth);
        System.out.println("-------------------------------------");
        TreeNode root1 = new TreeNode(8);
        TreeNode n1 = new TreeNode(9);
        TreeNode n2 = new TreeNode(2);
        root1.left = n1;
        root1.right = n2;
        boolean isbalanced = IsBalanced(root1);
        System.out.println(isbalanced);
        System.out.println("-------------------------------------");
        BFSTreeNode(root);
        System.out.println("-------------------------------------");
        printByLayer(root);
        System.out.println("-------------------------------------");
        boolean res = isSubTreeNode(root, root1);
        System.out.println(res);
        System.out.println("----------------所有路径---------------");
        getAllPath(root);
        TreeNode t7 = new TreeNode(7);
        System.out.println(hasNode(root, t5));
        System.out.println("---------------------------------------");
        List<TreeNode> list = getNodePath(root, t5);
        System.out.println("---------------------------------------");
        TreeNode node=getCommonParent(root,root,root);
        System.out.println(node.data);
        System.out.println(IsBalanced(t4));
    }

}