树的一些操作

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));
     }
 
 }