平衡二叉树（AVL）java实现

数的节点

 package com.ydp.tree.AVLTree;
 public class Node{
         private int data = 0;
         private Node lchild = null;
         private Node rchild = null;
         private Node parent = null;

         public Node(){};
         public Node(int data){
             this.data =  data;
         }
         public Node(int data,Node parent){
             this.data =  data;
             this.parent =  parent;
         }

         public boolean hasLChild(){
             return lchild != null;
         }

         public boolean hasRChild(){
             return rchild != null;
         }
         //当前节点树的深度
         public int getTreeDepth(){
             return getTreeDepth(this);
         }
         //指定节点树的深度
         protected int getTreeDepth(Node node){
             int depth =  0;
             if(node != null){
                 int ldepth = getTreeDepth(node.getLchild());
                 int rdepth = getTreeDepth(node.getRchild());
                 depth =1 + (ldepth>rdepth?ldepth:rdepth);
             }
             return depth;
         }

         public int getData() {
             return data;
         }
         public void setData(int data) {
             this.data = data;
         }
         public Node getLchild() {
             return lchild;
         }
         public void setLchild(Node lchild) {
             this.lchild = lchild;
         }
         public Node getRchild() {
             return rchild;
         }
         public void setRchild(Node rchild) {
             this.rchild = rchild;
         }
         public Node getParent() {
             return parent;
         }
         public void setParent(Node parent) {
             this.parent = parent;
         }

         public boolean isLChild(){

             return this.parent.hasLChild()?this.parent.getLchild().getData()==this.data:false;
         }

         public boolean equals(Node node){
             return this.data == node.getData();
         }

     }

平衡二叉树的实现

 package com.ydp.tree.AVLTree;

 import java.util.Stack;

 public class AVLTree {

     Node root = null;

     public static void main(String[] args) {
         AVLTree tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(30);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(60);
         tree.insert(30);
         tree.insert(45);
         tree.insert(20);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(60);
         tree.insert(70);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(60);
         tree.insert(55);
         tree.insert(70);
         tree.insert(80);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(45);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(60);
         tree.insert(30);
         tree.insert(45);
         tree.insert(47);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(60);
         tree.insert(55);
         tree.print();

         tree = new AVLTree();
         tree.insert(50);
         tree.insert(40);
         tree.insert(55);
         tree.insert(53);
         tree.insert(60);
         tree.insert(70);
         tree.print();

     }

     public void print(){
         System.out.println("树的深度："+this.getRoot().getTreeDepth());
         this.preOrder();
         System.out.println();
         this.midOrder();
         System.out.println("\n");
     }

     //插入节点数据
     public void insert(int data){
         if(this.root ==  null){
             this.root = new Node(data);
         }else{
             insert(data,this.root);
         }
     }
     //递归插入，将数据插入到合适的位置
     protected void insert(int data,Node node){
         if(data>node.getData()){
             if(node.hasRChild()){
                 insert(data,node.getRchild());
             }else{
                 node.setRchild(new Node(data,node));
             }
             if(getTreeDepth(node.getRchild())-getTreeDepth(node.getLchild())==2){
                 if(data>node.getRchild().getData()){
                     leftRotate(node);

                 }else{
                     rightLeftRotate(node);
                 }
             }            

         }else if(data<node.getData()){
             if(node.hasLChild()){
                 insert(data,node.getLchild());
             }else{
                 node.setLchild(new Node(data,node));
             }
             if(getTreeDepth(node.getLchild())-getTreeDepth(node.getRchild())==2){
                 if(data<node.getLchild().getData()){
                     rightRotate(node);
                 }else{
                     leftRightRotate(node);

                 }
             }

         }
     }

     public Node getRoot() {
         return root;
     }

     public void setRoot(Node root) {
         this.root = root;
     }

     //顺时针旋转
     public void rightRotate(Node node){
         System.out.println("顺时针："+node.getData());
         Node tmp = node.getLchild();
         if(node.getParent() == null){
             this.root=node.getLchild();
         }else{
             if(node.isLChild()){
                 node.getParent().setLchild(tmp);
             }else{
                 node.getParent().setRchild(tmp);
             }
         }
         tmp.setParent(node.getParent());
         node.setLchild(tmp.getRchild());
         node.setParent(tmp);
         tmp.setRchild(node);
     }
     //先顺后逆时针
     public void rightLeftRotate(Node node){
         System.out.println("先顺后逆时针："+node.getData());
         rightRotate(node.getRchild());
         leftRotate(node);
     }

     //逆时针
     public void leftRotate(Node node){
         System.out.println("逆时针："+node.getData());

         Node tmp = node.getRchild();
         if(node.getParent() == null){
             this.root=node.getRchild();
         }else{
             if(node.isLChild()){
                 node.getParent().setLchild(tmp);
             }else{
                 node.getParent().setRchild(tmp);
             }

         }
         tmp.setParent(node.getParent());
         node.setRchild(tmp.getLchild());
         node.setParent(tmp);
         tmp.setLchild(node);

     }

     //逆时针
     public void leftRightRotate(Node node){
         System.out.println("先逆后顺时针："+node.getData());
         leftRotate(node.getLchild());
         rightRotate(node);
     }

      //先序遍历
      public void preOrder(){
          Stack<Node> stack = new Stack<Node>();
          Node node = root;
          while(node != null || !stack.empty()){
              while(node != null){
                  System.out.print(node.getData()+" ");
                  stack.push(node);
                  node = node.getLchild();
              }
              node = stack.pop();
              node =  node.getRchild();
          }
      }

      //中序遍历
      public  void midOrder(){
          Stack<Node> stack = new Stack<Node>();
          Node node = root;
          while(node != null || !stack.empty()){
              while(node != null){
                  stack.push(node);
                  node = node.getLchild();
              }
              node = stack.pop();
              System.out.print(node.getData()+" ");
              node =  node.getRchild();
          }
      }

      protected int getTreeDepth(Node node){
             int depth =  0;
             if(node != null){
                 int ldepth = getTreeDepth(node.getLchild());
                 int rdepth = getTreeDepth(node.getRchild());
                 depth =1 + (ldepth>rdepth?ldepth:rdepth);
             }
             return depth;
         }
 }