Java实现二叉树（平衡树/搜索二叉树的判断）

来源：互联网发布：网络直销的化妆品编辑：程序博客网时间：2024/06/05 02:08

Java实现二叉树（建议从main方法开始看(程序最下方)）

package work;
public class Tree {

/**
* 二叉树基本Java实现
*
* */
private static TreeNode root = null;
public Tree() {

root = new TreeNode(4);
}
private class TreeNode {

private int key = 0;
private TreeNode leftchild= null;
private TreeNode rightChild = null;

public TreeNode(int key) {

  this.key =key;
  this.leftchild = null;
        this.rightChild = null;
}
}
/**
*
* 创建一个二叉树
*
* 格式：
* A
*    B C
* D    E     F    G
*    H
*    I
* */
//创建二叉树（1/2）
public void createTreeNode(TreeNode root) {

  TreeNode node1 = new TreeNode(1);
  TreeNode node2 = new TreeNode(2);
  TreeNode node3 = new TreeNode(3);
  TreeNode node5 = new TreeNode(5);
  TreeNode node6 = new TreeNode(6);
  TreeNode node7 = new TreeNode(7);
  TreeNode node8 = new TreeNode(8);

  root.leftchild = node2;
  root.rightChild = node6;
  root.leftchild.leftchild = node1;
  root.leftchild.rightChild = node3;
  root.rightChild.leftchild = node5;
  root.rightChild.rightChild = node7;
  root.rightChild.rightChild.rightChild = node8;
}
//创建二叉树（2/2）
public void createTreeNodes() {
  TreeNode node1=new TreeNode(1);
  TreeNode node2=new TreeNode(2);
  TreeNode node3=new TreeNode(3);
  TreeNode node4=new TreeNode(4);
  TreeNode node5=new TreeNode(5);
  TreeNode node6=new TreeNode(6);
  TreeNode node7=new TreeNode(7);
  node4.leftchild=node2;
  node4.rightChild=node6;
  node2.leftchild=node1;
  node2.rightChild=node3;
  node6.leftchild=node5;
  node6.rightChild=node7;
}

//树的高度（1/2）
public int height(TreeNode subTree) {

  if(subTree==null) {

   return 0;
  }else {
   int i = height(subTree.leftchild);
   int j = height(subTree.rightChild);
   return i<j?j+1:i+1;
  }
}
//树的高度（2/2）

public int height2(TreeNode subTree) {

  if(subTree==null) {

   return 0;
  }else {

   int height2 = height2(subTree.leftchild);
   int height22 = height2(subTree.rightChild);

   return Math.max(height2, height22)+1;
  }

}

//树的节点的个数

public int size(TreeNode subTree) {

  if(subTree==null) {

   return 0;

  }else {

   return 1+size(subTree.leftchild)+size(subTree.rightChild);
  }
}
//查询某个节点的值
public void visted(TreeNode subTree) {

         System.out.println("key:" + subTree.key );
}

//获取每个节点的值

public void getChild(TreeNode subTree) {

   if(subTree!=null) {

    visted(subTree);

    getChild(subTree.leftchild);
    getChild(subTree.rightChild);
   }
}

public void isBanlances(TreeNode subTree) {

   int banlance = isBanlance(subTree);


   if(banlance !=-1) {


    System.out.println("是平衡二叉树");
   }else {


    System.out.println("不是平衡二叉树");
   }


}

//判断是否为平衡二叉树   （同时返回二叉树的层数）
public int isBanlance(TreeNode subTree) {

   if(subTree ==null) {
    return 0;
   }
   int leftHeight=this.isBanlance(subTree.leftchild);

   if(leftHeight==-1) return -1;

   int rightHeight=this.isBanlance(subTree.rightChild);


   if(rightHeight==-1) return -1;


   if(Math.abs(leftHeight-rightHeight)>1) return -1;

   return Math.max(leftHeight,rightHeight)+1;
}

//判断是否为排序二叉树
int temp = 0;
boolean flag = true;
public void isPaiXus(TreeNode subTree) {

   isPaiXu(subTree);

   if(flag){
   System.out.println("是搜索二叉树");
   }else{
   System.out.println("不是搜索二叉树");
   }
}

public void isPaiXu(TreeNode subTree) {

   if(subTree==null) {

    return;

   }else {

   this.isPaiXu(subTree.leftchild);

    if(subTree.key<temp) {
     System.out.println(subTree.key);
     System.out.println(temp+"temp");
     flag = false;
     return;

    }

    temp = subTree.key;

    this.isPaiXu(subTree.rightChild);

   }



}

public static void main(String[] args) {

  Tree bt = new Tree();
  //创建二叉树先创建父跟再创建子树  第二种创建方法
  bt.createTreeNode(root);    bt.createTreeNodes();
  //是否为平衡二叉树结果为-1则不是，是平衡二叉树会返回二叉的高度
  int banlance = bt.isBanlance(root);
     System.out.println(banlance);
      //判断是都为搜索二叉树
      bt.isPaiXus(root);
      //遍历二叉树的元素
//      bt.getChild(root);
}
}

阅读全文

0 0