二叉树的基本操作

package binaryTree；

/*
 * 
 * 1、二叉树的先序创建


2、二叉树的递归先序遍历


3、二叉树的非递归先序遍历


4、二叉树的递归中序遍历


5、二叉树的非递归中序遍历


6、二叉树的递归后序遍历


7、二叉树的非递归后序遍历


8、二叉树的层次遍历
 * */
public class Node<T> {
 private T value;
 private Node<T> left;
 private Node<T> right;
 
 public Node(){
 }
 public Node(Node<T> left, Node<T> right, T value){
   this.left = left;
   this.right = right;
   this.value = value;
 }
 public Node(T value){
   this(null, null, value);
 }
 
 public Node<T> getLeft(){
   return this.left;
 }
 public void setLeft(Node<T> left){
   this.left = left;
 }
 public Node<T> getRight(){
   return this.right;
 }
 public void setRight(Node<T> right){
   this.right = right;
 }
 public T getValue(){
   return this.value;
 }
 public void setValue(T value){
   this.value = value;
 }
@Override
public int hashCode() {
return value.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (value == null) {
if (other.value != null)
return false;
} else if (!value.equals(other.value))
return false;
return true;
}

}

package binaryTree;


import java.util.LinkedList;
public class BinaryTree<T> {


    private Node<T> root=null;
    
    public BinaryTree(){
   
    }
    public BinaryTree(Node<T> root){
    this.root=root;
    }
    
    
    public Node<T> getRoot() {
return root;
}
    
    public T getParentValue(T data){
    Node<T> node= parent(new Node(data));
    if(data!=null){
    return node.getValue();
    }
    return null;
    }
    //返回双亲结点  
    public Node<T> parent(Node<T> element){  
        return (root==null|| root.equals(element))?null:parent(root, element);  
    }  
      
    public Node<T> parent(Node<T> subTree,Node<T> element){  
        if(subTree==null)  
            return null;  
        if(subTree.getLeft().equals(element)||subTree.getRight().equals(element))  
            //返回父结点地址  
            return subTree;  
        Node<T> p;  
        //现在左子树中找，如果左子树中没有找到，才到右子树去找  
        if((p=parent(subTree.getLeft(), element))!=null)  
            //递归在左子树中搜索  
            return p;  
        else  
            //递归在右子树中搜索  
            return parent(subTree.getRight(), element);  
    } 
    
    public Node<T> getLeftChildNode(Node<T> element){  
        return (element!=null)?element.getLeft():null;  
    }  
      
    public Node<T> getRightChildNode(Node<T> element){  
        return (element!=null)?element.getRight():null;  
    } 

public void createBinaryTree(){
         this.root=createBinaryTree(root);
    }
    
    private Node<T> createBinaryTree(Node<T> node){
    Scanner sc=new Scanner(System.in);
    String data=sc.nextLine();
    if(data.equalsIgnoreCase("#")){
    return null;
    }else{
    node=new Node<T>((T)data);
    node.setLeft(createBinaryTree(node.getLeft()));
    node.setRight(createBinaryTree(node.getRight()));
    return node;
    }
    }
    
    /**先序递归遍历二叉树*/
    public void preOrder(){
    preOrder(root);
    }
    
    private void preOrder(Node<T> root){
    if(root!=null){
    System.out.print(root.getValue()+"  ");
    preOrder(root.getLeft());
    preOrder(root.getRight());
    }
    }
    
    public void  nrPreOrderTraverse(){
    nrPreOrderTraverse(root);
    }
    /**先序非递归遍历二叉树*/
 private void nrPreOrderTraverse(Node<T> root){
   Stack<Node<T>> stack = new Stack<Node<T>>();
   Node<T> node = root;
   while(node != null || !stack.isEmpty()){
     while(node != null){
       System.out.print(node.getValue()+"  ");
       stack.push(node);
       node = node.getLeft();
     }
     node = stack.pop();
     node = node.getRight();
   }
 }
    
    
   
    
    /**中序递归遍历二叉树*/
 public void inOrderTraverse(){
   inOrderTraverse(root);
 }
 private void inOrderTraverse(Node<T> node) {
   if(node != null){
     inOrderTraverse(node.getLeft());
     System.out.print(node.getValue()+"  ");
     inOrderTraverse(node.getRight());
   }
 }
 
 /**中序非递归遍历二叉树*/
 
 public void nrInOrderTraverse(){
 nrInOrderTraverse(root);
 }
 private void nrInOrderTraverse(Node<T> root){
   Stack<Node<T>> stack = new Stack<Node<T>>();
   Node<T> node = root;
   while(node != null || !stack.isEmpty()){
     while(node != null){
       stack.push(node);
       node = node.getLeft();
     }
     node = stack.pop();
     System.out.println(node.getValue());
     node = node.getRight();
   }
 }
 
 
 
 /**后序递归遍历二叉树*/
 public void postOrderTraverse(){
   postOrderTraverse(root);
 }
 private void postOrderTraverse(Node<T> node) {
   if(node != null){
     postOrderTraverse(node.getLeft());
     postOrderTraverse(node.getRight());
     System.out.print(node.getValue()+"  ");
   }
 }

 /**后序非递归遍历二叉树*/
 public void nrPostOrderTraverse(){
 nrPostOrderTraverse(root);
 }
 
 private void nrPostOrderTraverse(Node<T> root){
   Stack<Node<T>> stack = new Stack<Node<T>>();
   Node<T> node = root;
   Node<T> preNode = null;//记录之前遍历的右结点
   while(node != null || !stack.isEmpty()){
     while(node != null){
       stack.push(node);
       node = node.getLeft();
     }
     node=stack.peek();
     
     /**如果右结点为空，或者右结点之前遍历过，打印根结点*/
     if(node.getRight() == null || node.getRight() == preNode){
       System.out.print(node.getValue()+" ");
       node = stack.pop();
       preNode = node;
       node = null;
     }
     else{
       node = node.getRight();
     }
   }
 }
 
 
 /**层次遍历二叉树*/
 public void levelTraverse(){
   levelTraverse(root);
 }
 private void levelTraverse(Node<T> node) {
   Queue<Node<T>> queue = new LinkedList<Node<T>>();
   queue.add(node);
   while(!queue.isEmpty()){
    Node<T> node1=queue.poll();
    System.out.print(node1.getValue()+"  ");
    if(node1.getLeft()!=null){
    queue.add(node1.getLeft());
    }
    if(node1.getRight()!=null){
    queue.add(node1.getRight());
    }
   }
 }
 
 
  //在释放某个结点时，该结点的左右子树都已经释放，  
   //所以应该采用后续遍历，当访问某个结点时将该结点的存储空间释放  
   public void destroy(Node<T> subTree){  
       //删除根为subTree的子树  
       if(subTree!=null){  
           //删除左子树  
           destroy(subTree.getLeft());  
           //删除右子树  
           destroy(subTree.getRight());  
           //删除根结点  
           subTree=null;  
       }  
   }
   
   
   public int height(){
    return height(root);
   }
   private int height(Node<T> subTree){  
       if(subTree==null)  
           return 0;//递归结束：空树高度为0  
       else{  
           int i=height(subTree.getLeft());  
           int j=height(subTree.getRight());  
           return (i<j)?(j+1):(i+1);  
       }  
   }  
     
   public int size(){
    return size(root);
   }
   private int size(Node<T> subTree){  
       if(subTree==null){  
           return 0;  
       }else{  
           return 1+size(subTree.getLeft())+size(subTree.getRight());  
       }  
   }  

public static void main(String[] args) {
BinaryTree<String>  bt=new BinaryTree<String>();
bt.createBinaryTree();
bt.preOrder();
System.out.println();
bt.nrPreOrderTraverse();
System.out.println();
bt.inOrderTraverse();
System.out.println();
bt.inOrderTraverse();
System.out.println();
bt.postOrderTraverse();
System.out.println();
bt.nrPostOrderTraverse();
System.out.println();
bt.levelTraverse();
System.out.println();
System.out.println(bt.size());
System.out.println();
System.out.println(bt.height());
System.out.println(bt.getParentValue("b"));
}


}