数据结构之二叉树实践练习

二叉树定义：二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。如果不考虑连通性，允许图中有多个连通分量，这样的结构叫做森林。
     

(1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。

(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。

(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树基本操作练习

二叉树结构定义

package BinaryTree;

public class BinaryTreeNode {
private int data;
private BinaryTreeNode left;
private BinaryTreeNode right;
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryTreeNode getLeft() {
return left;
}
public void setLeft(BinaryTreeNode left) {
this.left = left;
}
public BinaryTreeNode getRight() {
return right;
}
public void setRight(BinaryTreeNode right) {
this.right = right;
}

}

   二叉树操作

package BinaryTree;

import java.util.Queue;

import ArrayQueue.ArrayQueue;
import ArrayStack.ArrayStack;

public class BinaryTree{

private static final int INT_MIN = 0;
BinaryTreeNode root;

   public BinaryTree(BinaryTreeNode root) {

this.root = root;
}
//递归前序遍历
   public void PreOder( BinaryTreeNode root){
   if(root!=null){
   System.out.println(root.getData());
   PreOder(root.getLeft());
   PreOder(root.getRight());
   }
   }
   //非递归前序遍历
   public void preOrderBySave(){
   ArrayStack stack=new ArrayStack();
   if(root!=null){
   System.out.println("根为空");
   }
   while(true){
   while(root!=null){
    System.out.println(root.getData());
    stack.push(root);
    root=root.getLeft();
   }
   if(stack.isEmpty())
   break;
   root =(BinaryTreeNode) stack.pop();
   root=root.getRight();
   }
   
   
   }
   //递归中序遍历
   public void inOder(  BinaryTreeNode root){
   if(root!=null){
   inOder(root.getLeft());
   System.out.println(root.getData());
   inOder(root.getRight());
   }
   }
   //非递归中序遍历
   public void inOrderBySave(){
   ArrayStack stack=new ArrayStack();
   if(root!=null){
   System.out.println("根为空");
   }
   
   while(true){
   while(root!=null){
    stack.push(root);
    root=root.getLeft(); 
   
   
   			  
   }
   if(stack.isEmpty())
   break;
   root =(BinaryTreeNode) stack.pop();
   System.out.println(root.getData());
   root=root.getRight();
   }		   
   
   }
   //后续遍历
   public void postOder(  BinaryTreeNode root){
   if(root!=null){
   postOder(root.getLeft());		 
   postOder(root.getRight());
   System.out.println(root.getData());
   }
   }
   //非递归后序遍历
   public void postOrderBySave(){
   ArrayStack stack=new ArrayStack();
   if(root!=null){
   System.out.println("根为空");
   }
   
   while(true){
   while(root!=null){
    stack.push(root);
    root=root.getLeft(); 
   
   
   			  
   }
   if(stack.isEmpty())
   break;
   root =(BinaryTreeNode) stack.pop();
   root=root.getRight();
   System.out.println(root.getData());
   }		   
   
   }
   //层次遍历
   public void LevelOrder(BinaryTreeNode root){
ArrayQueue queue=new ArrayQueue();
   	BinaryTreeNode temp; 
if(root==null){
System.out.println("层次遍历队列为空");
return;
}

queue.enQueue(root);
   while(!queue.isEmpty()){
   temp=(BinaryTreeNode) queue.deQueue();
  
   if(temp.getLeft()!=null)
   queue.enQueue(temp.getLeft());
   if(temp.getRight()!=null)
   queue.enQueue(temp.getRight());
   }
  
   } 
   //找最大值
  public  int findMax(BinaryTreeNode root){
  int root_val,left,right,max=INT_MIN;
  if(root!=null){
  root_val=root.getData();
  left=findMax(root.getLeft());
  right=findMax(root.getRight());
  if(left>right)
  max=left;		 
else{
  max=right;
  if(right<root_val)
  max=root_val;
  }
  
  }
  return max;
  }
  //用非递归方式查找最大值
  public int findMaxByQueue(){
  BinaryTreeNode temp;
  int max=INT_MIN;
  ArrayQueue queue=new ArrayQueue(10);
  if(root!=null)
  queue.enQueue(root);
     System.out.println(root.getData());
  
  while(!queue.isEmpty()){
  temp=(BinaryTreeNode) queue.deQueue();
  System.out.println(temp.getData());
  if(max<temp.getData())
  max=temp.getData();
  if( temp.getLeft()!=null){
System.out.println(" 左节点入队");
     queue.enQueue( temp.getLeft());
     }
  if(temp.getRight()!=null){
  System.out.println(" 右节点节入队");
     queue.enQueue( temp.getRight());
  }
  } 
  return max;
  }
  //二叉树搜索元素
  public boolean findBinaryTree(BinaryTreeNode root,int data){
  boolean temp=false;
  if(root==null){
  return false;
  }else{
  if(data==root.getData()){
  System.out.println("存在该元素");
  return true;
  }else{//当前节点没找到，继续向子节点递归
  if(root.getLeft()!=null){
temp=  findBinaryTree(root.getLeft(), data);
      if(temp=true){
    	  return temp;
      }else{
    	  return findBinaryTree(root.getRight(), data);
    	  
      }	 						 
       }
       }
     }
return temp;
  }
  //层次遍历方式搜索二叉树
  public boolean  findByLevelOrder(int data){
  BinaryTreeNode temp;
  ArrayQueue queue=new ArrayQueue();
  if(root!=null){
  queue.enQueue(root);
  }
  while(queue.isEmpty()){
  temp=(BinaryTreeNode) queue.deQueue();
  if(temp.getData()==data){
  System.out.println("存在该元素");
  return true;
  }else{
  if(temp.getLeft()!=null){
    queue.enQueue(temp.getLeft());     
  }
  if(temp.getRight()!=null){
    queue.enQueue(temp.getRight());     
  }
   }
  
  }
return false;
  } 
  //插入二叉树节点
  public void InsertTree(int data){
  ArrayQueue inQueue=new ArrayQueue();
  BinaryTreeNode temp;
  BinaryTreeNode newNode=new BinaryTreeNode();
  newNode.setData(data);
  newNode.setLeft(null);
  newNode.setRight(null);
  if(root!=null){
  inQueue.enQueue(root);
  }
  while(!inQueue.isEmpty()){
  temp=(BinaryTreeNode) inQueue.deQueue();
  if(temp.getLeft()!=null){
  inQueue.enQueue(temp.getLeft());
  }else{
  temp.setLeft(newNode);
  return;
  }
  if(temp.getRight()!=null){
  inQueue.enQueue(temp.getRight());
  }else{
  temp.setRight(newNode);
  return;
  }
  
  }
  
  }
}