二叉树

Eclipse java 工程：
demo： http://download.csdn.net/detail/keen_zuxwang/9877670

import java.util.ArrayDeque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinaryTree0 {
static class TreeNode{
int value;
TreeNode left;
TreeNode right;

    public TreeNode(int value){          this.value=value;      }      public TreeNode(){          }}  static int counter = 0;TreeNode root;  public BinaryTree0(int[] array){      root=makeBinaryTreeByArray(array,1);  //makeBinaryTreeByArray(array,1);  }  public BinaryTree0(){      root = null;}public TreeNode buildTree0(TreeNode root, int[] a, int i) {    if (i < a.length) {        if (a[i] == 0) {            root = null;        } else {            if(root == null){               root = new TreeNode();            }            TreeNode lchild = new TreeNode();            TreeNode rchild = new TreeNode();            root.value = a[i];            root.left = buildTree0(lchild, a, ++counter);            root.right = buildTree0(rchild, a, ++counter);        }    }    return root;}public void buildTree(TreeNode node,int data){      if(root == null){          root = new TreeNode(data);      }else{          if(data < node.value){              if(node.left == null){                  node.left = new TreeNode(data);              }else{                  buildTree(node.left,data);              }          }else{              if(node.right == null){                  node.right = new TreeNode(data);              }else{                  buildTree(node.right,data);              }          }      }           } /**  * 采用递归的方式创建一颗二叉树  * 传入的是二叉树的数组表示法  * 构造后是二叉树的二叉链表表示法  */  public static TreeNode makeBinaryTreeByArray(int[] array,int index){      if(index<array.length){          int value=array[index];          if(value!=0){              TreeNode t=new TreeNode(value);              array[index]=0;              t.left=makeBinaryTreeByArray(array,index*2);              t.right=makeBinaryTreeByArray(array,index*2+1);              return t;          }      }      return null;  }  //获取最大深度public int getMaxDepth(){    return getMaxDepth(root);}private int getMaxDepth(TreeNode root) {        if (root == null)        return 0;    else {        int left = getMaxDepth(root.left);        int right = getMaxDepth(root.right);        return Math.max(left, right)+1;    }}// 获取最大宽度 public int getMaxWidth() {    return getMaxWidth(root);}// 上一层遍历完成后，下一层的所有节点已经放到队列中，此时队列中的元素个数就是下一层的宽度private int getMaxWidth(TreeNode root) {    if (root == null)        return 0;    Queue<TreeNode> queue = new ArrayDeque<TreeNode>();    int layer = 0;    int maxWitdth = 1; // 最大宽度    queue.add(root); // 入队    while (true) {        int len = queue.size(); // 当前层的节点个数        if (len == 0)            break;        layer++;        System.out.print("\n第"+layer+"层, sum = "+queue.size()+":  ");          while (len > 0) {// 如果当前层，还有节点            TreeNode t = queue.poll();            System.out.print(t.value+"  ");             len--;            if (t.left != null)                queue.add(t.left); // 下一层节点入队            if (t.right != null)                queue.add(t.right);// 下一层节点入队        }        maxWitdth = Math.max(maxWitdth, queue.size());    }    System.out.print("\n");    return maxWitdth;}//节点个数  public int size(){      return size(root);  }  private int size(TreeNode t){      if(t==null){          return 0;      }else{          return 1+size(t.left)+size(t.right);      }  }  //返回双亲结点  public TreeNode parent(TreeNode t){      return (root==null|| root==t)?null:parent(root, t);  }  public TreeNode parent(TreeNode subTree,TreeNode element){      if(subTree==null)          return null;      if(subTree.left==element||subTree.right==element) {         return subTree; //返回父结点地址       }    TreeNode p;      //现在左子树中找，如果左子树中没有找到，才到右子树去找      if((p=parent(subTree.left, element))!=null) { //递归在左子树中搜索          return p;      }else{ //递归在右子树中搜索          return parent(subTree.right, element);      }}  //获取左子树public TreeNode getLeftChildNode(TreeNode t){      return (t!=null)?t.left:null;  }  //获取右子树public TreeNode getRightChildNode(TreeNode t){      return (t!=null)?t.right:null;  }  public TreeNode getRoot(){      return root;  }  

//清空树
public void makeEmpty(){
root=null;
}
//判断树是否为空
public boolean isEmpty(){
return root==null;
}

public void traverse(){      traverse(root);}private void traverse(TreeNode t){      System.out.println("  "+t.value);;      traverse(t.left);      traverse(t.right);  } TreeNode node=null;boolean flagOver=false;//查找集合中是否有元素value,有返回true， 查找需要遍历二叉树public TreeNode contains(int value){     System.out.print("-------------contains-------------\n");    System.out.print("find value "+value+"\n");    node=null;    try {          contains(root, value);     } catch (Exception e) {         System.out.println(e);      }     //System.out.print("\n           find over            \n");    return node;}//私有重载private TreeNode contains(TreeNode t, int value) throws Exception {    if(flagOver){  //1、设置标志，递归推出        return null;    }    if(t==null){        return null;    }    if(t.value != value){        System.out.print(t.value+"  ");        contains(t.left, value);        contains(t.right, value);        return null;    }else{        System.out.print("\nhava found the value "+t.value+"\n");        flagOver = true;        node = t;        return node;        //throw new Exception(); // 抛异常退出 或者 单开线程    }}int min = 0;int max = 0;TreeNode p;//查找集合中的最小值public int findMin(){    p = root;    min = root.value;    return  findMin(root).value;}private TreeNode findMin(TreeNode t) {    if(t!=null){        //System.out.print(t.value+"  ");        if(t.value < min){           min = t.value;           p = t;        }        findMin(t.left);        findMin(t.right);    }    return p;}//递归方式遍历：先序、中序、后序//先序遍历打印public void printTreeP(){    printTreeP(root);}private void printTreeP(TreeNode t) { //Parent->Childl->Childr    if(t!=null){        System.out.print(t.value+"  ");        printTreeP(t.left);        printTreeP(t.right);    }}//中序遍历打印public void printTreeM(){    printTreeM(root);}private void printTreeM(TreeNode t) { //Childl->Parent->Childr    if(t!=null){        printTreeM(t.left);        System.out.print(t.value+"  ");        printTreeM(t.right);    }}//后序遍历打印public void printTreeN(){    printTreeN(root);}private void printTreeN(TreeNode t) { //Childl->Childr->Parent    if(t!=null){        printTreeN(t.left);        printTreeN(t.right);        System.out.print(t.value+"  ");    }}//非递归方式遍历：深度优先遍历、广度优先遍历//深度优先遍历： 先序、中序、后序， 需要辅助数据结构：栈  （栈的LIFO特性）//前序遍历public void PreOrder(){    PreOrder(root);}//前序遍历的非递归实现  private void PreOrder(TreeNode p){      Stack<TreeNode> stack=new Stack<TreeNode>();      stack.push(p);             while(stack.isEmpty()==false){          TreeNode node=stack.pop();          System.out.print(node.value+"  ");          if(node.right!=null){              stack.push(node.right);          }          if(node.left!=null){              stack.push(node.left);          }           }}  //中序遍历public void InOrder(){    InOrder(root);}//中序遍历的非递归实现  private void InOrder(TreeNode p){      Stack<TreeNode> stack =new Stack<TreeNode>();      TreeNode node =p;      while(node!=null||stack.size()>0){          //存在左子树          while(node!=null){              stack.push(node);              node=node.left;          }          //栈非空          if(stack.size()>0){              node=stack.pop();              System.out.print(node.value+"  ");             node=node.right;          }      }  }  //中序遍历public void PostOrder(){    PostOrder(root);}//后序遍历的非递归实现  private void PostOrder(TreeNode p){      Stack<TreeNode> stack=new Stack<TreeNode>();      TreeNode node =p;      while(p!=null){          //左子树入栈          for(; p.left!=null; p=p.left){              stack.push(p);          }          //当前结点无右子树或右子树已经输出          while(p!=null&&(p.right==null||p.right==node)){              System.out.print(p.value+"  ");             //纪录上一个已输出结点              node =p;              if(stack.empty())                  return;              p=stack.pop();          }          //处理右子树          stack.push(p);          p=p.right;      }  } //广度优先遍历(层次遍历) ，需要辅助数据结构：队列 （利用队列的FIFO特性）public void levelOrderTraversal(){      if(root==null){          System.out.println("empty tree");          return;      }      //Queue<TreeNode> queue = new LinkedList<TreeNode>();    //queue.offer(root);// 从根节点入队列    ArrayDeque<TreeNode> queue=new ArrayDeque<TreeNode>();      queue.add(root); //或queue.offer()    while(queue.isEmpty()==false){          TreeNode node=queue.remove();  //或queue.poll()  头部出对（顺序）：13 65 5 97 25 37 22 4 28 32         System.out.print(node.value+"  ");          //尾部入对（顺序）：13 65 5 97 25 37 22 4 28 32         if(node.left!=null){              queue.add(node.left);          }          if(node.right!=null){              queue.add(node.right);          }     }      System.out.print("\n");  }  /**   *                   13  *                /      \  *              65        5  *             /  \     /   \  *            97  25    0   37  *           / \  / \  / \  / \  *          22  0 4 28 0 0 32 47    0表示没有， 只是为了概念性显示才列出来 */  public static void main(String[] args) {      int[] arr={0,13,65,5,97,25,0,37,22,0,4,28,0,0,32,47,0};      BinaryTree0 tree=new BinaryTree0(arr);      //int[] a = {13,65,5,97,25,37,22,4,28,32,47} ;//{2,4,12,45,21,6,111};      //BinaryTree0 aTree = new BinaryTree0();      //for (int i = 0; i < a.length; i++) {      //  aTree.buildTree(aTree.root, a[i]);      //}      System.out.print("二叉树深度\n");     System.out.print(tree.getMaxDepth());    System.out.print("\n");      System.out.print("二叉树宽度");     System.out.print(tree.getMaxWidth());    System.out.print("\n");     System.out.print("\n");     System.out.print("-----------------递归遍历-----------------\n");    System.out.print("二叉树先序遍历\n");     tree.printTreeP();     System.out.print("\n\n");      System.out.print("二叉树中序遍历\n");     tree.printTreeM();      System.out.print("\n");    System.out.print("\n");      System.out.print("二叉树后序遍历\n");     tree.printTreeN();      System.out.print("\n\n");     System.out.print("-----------------非递归遍历-----------------\n");    System.out.print("二叉树深度优先遍历： \n");      System.out.print("二叉树先序遍历\n");     tree.PreOrder();     System.out.print("\n\n");      System.out.print("二叉树中序遍历\n");     tree.InOrder();      System.out.print("\n");    System.out.print("\n");      System.out.print("二叉树后序遍历\n");     tree.PostOrder();     System.out.print("\n\n");      System.out.print("二叉树广度优先遍历\n");     tree.levelOrderTraversal();     System.out.print("\n");      System.out.print("二叉树大小\n");     System.out.print(tree.size());    System.out.print("\n\n");      TreeNode p = tree.contains(22);    if(p != null){        System.out.print("\n");          System.out.print("查找子树：\n");         System.out.print(p.value);        System.out.print("\n");     }    int min = tree.findMin();    System.out.print("\n");      System.out.print("最小值：\n");     System.out.print(min);}  

}