java项目---用java实现二叉平衡树(AVL树)并打印结果(详)

  1 package Demo;
  2
  3 public class AVLtree  {
  4     private Node root;                      //首先定义根节点
  5
  6     private static class Node{                              //定义Node指针参数
  7         private int key;                //节点
  8         private int balance;                    //平衡值
  9         private int height;             //树的高度
 10         private Node left;                      //左节点
 11         private Node right;             //右节点
 12         private Node parent;                    //父母节点
 13
 14
 15     Node(int key, Node parent){             //构造器中引用该构造器正在初始化的对象
 16         this.key = key;
 17         this.parent = parent;
 18
 19         }
 20     }
 21     public boolean insert(int key){             //判断这里是否能插入新的节点
 22         if(root == null){
 23             root = new Node(key,null);
 24             return true;
 25         }
 26
 27         Node n = root;
 28         while (true){                           //如果根节点下的子节点和新插进来的子节点相同
 29             if(n.key == key)
 30                 return false;                   //则不进行插入操作
 31
 32             Node parent = n;
 33
 34             boolean goLeft = n.key > key;           //判断新的节点插入父母节点的左边or右边
 35             n = goLeft ? n.left : n.right;             //小的话插左边,大的话插右边
 36
 37             if(n == null){
 38                 if(goLeft){
 39                     parent.left = new Node (key,parent);
 40                 }else{
 41                     parent.right = new Node(key,parent);
 42                 }
 43                 rebalance(parent);
 44                 break;
 45             }
 46         }
 47         return true;
 48     }
 49
 50     private void delete(Node node){                     //删除节点
 51         if(node.left == null && node.right == null){
 52             if(node.parent == null){
 53                 root = null;
 54             }else{
 55                 Node parent = node.parent;
 56                 if(parent.left == node){            //如果父母节点的左孩子节点和根节点一样
 57                     parent.left = null;             //则左节点为空
 58                 }else{
 59                     parent.right = null;            //反之右节点为空
 60                 }
 61                 rebalance(parent);
 62             }
 63             return ;
 64         }
 65
 66         if(node.left != null){              //如果左节点不空
 67             Node child = node.left;
 68             while(child.right != null)child = child.right;
 69             node.key = child.key;
 70             delete(child);
 71         }else{
 72             Node child = node.right;
 73             while (child.left != null)child = child.left;
 74             node.key = child.key;
 75             delete(child);
 76             }
 77         }
 78
 79         public void Delete(int delKey){
 80         if(root == null)
 81             return;
 82
 83         Node child = root;
 84         while (child != null){
 85             Node node = child;                           //交换根节点给node , 再判断新的孩子节点插在哪里
 86             child = delKey >= node.key ? node.right : node.left;
 87             if(delKey == node.key){
 88                 delete(node);
 89                 return;
 90             }
 91         }
 92     }
 93
 94     private void setBalance(Node... nodes){
 95         for(Node n : nodes){
 96             reheight(n);
 97             n.balance = height(n.right) - height(n.left);           //平衡因子,任意节点左右子树高度差
 98         }
 99     }
100
101     private void rebalance (Node n){
102         setBalance(n);
103
104         if(n.balance == -2){
105             if(height(n.left.left) >= height(n.left.right))
106                 n = rotateRight(n);
107             else
108                 n = rotateLeftThenRight(n) ;
109
110         }else if(n.balance == 2){                                   //等于2和-2都是不平衡的,需要重新调整
111             if(height(n.right.right) >= height(n.right.left))
112                 n = rotateLeft(n);
113             else
114                 n = rotateRightThenLeft(n);
115
116         }
117
118         if(n.parent != null){
119             rebalance(n.parent);
120         }else{
121             root = n;
122         }
123     }
124
125     private Node rotateLeft(Node a){
126
127         Node b = a.right;
128         b.parent = a.parent;
129
130         a.right = b.left;
131
132         if(a.right != null)
133             a.right.parent = a;
134
135         b.left = a;
136         a.parent = b;
137
138         if(b.parent != null){
139             if(b.parent.right == a){
140                 b.parent.right = b;
141             }else{
142                 b.parent.left = b;
143             }
144         }
145
146         setBalance(a, b);
147
148         return b;
149     }
150
151     private Node rotateRight(Node a){
152
153         Node b = a.left;
154         b.parent = a.parent;
155
156         a.left = b.right;
157
158         if(a.left != null){
159             a.left.parent = a;
160
161             b.right = a;
162             a.parent = b;
163
164             if(b.parent.right == a){
165                 b.parent.right = b;
166             }else{
167                 b.parent.left = b;
168             }
169         }
170
171         setBalance(a, b);
172
173         return b;
174     }
175
176     private Node rotateLeftThenRight(Node n){
177         n.left = rotateLeft(n.left);
178         return rotateRight(n);
179     }
180
181     private Node rotateRightThenLeft(Node n){
182         n.right = rotateRight(n.right);
183         return rotateLeft(n);
184     }
185
186     private int height (Node n){
187         if(n == null)
188             return -1;
189         return n.height;
190     }
191
192
193
194     public void printBalance(){
195         printBalance(root);
196     }
197
198     private void printBalance(Node n){
199         if(n != null){
200             printBalance(n.left);
201             System.out.printf("%s ",n.balance);
202             printBalance(n.right);
203         }
204     }
205
206     private void reheight(Node node){
207         if(node != null){
208             node.height = 1 + Math.max(height(node.left),height(node.right));           //新的二叉平衡树高度为:
209         }
210     }
211     public static void main(String[] args) {
212         AVLtree tree = new AVLtree();
213
214         System.out.println("Inserting values 1 to 10");     //最后输出的结果代表平衡因子,0为左右子树高度相等,1为左右子树高度相差1层
215         for (int i = 1; i < 10; i++)
216             tree.insert(i);
217
218         System.out.println("Print balance : ");
219         tree.printBalance();
220     }
221 }

    可以动手画一下生成的AVL树,亲测算法符合结果。



原文地址:https://www.cnblogs.com/kkuuklay/p/10462193.html

时间: 2024-10-10 23:55:41

java项目---用java实现二叉平衡树(AVL树)并打印结果(详)的相关文章

平衡二叉搜索树(AVL树,红黑树)数据结构和区别

平衡二叉搜索树(Balanced Binary Search Tree) 经典常见的自平衡的二叉搜索树(Self-balancing Binary Search Tree)有 ① AVL树 :Windows NT 内核中广泛使用 ② 红黑树:C++ STL(比如 map.set )Java 的 TreeMap.TreeSet.HashMap.HashSet  Linux 的进程调度  Ngix 的 timer 管理 1 AVL树  vs  红黑树 ①AVL树 平衡标准比较严格:每个左右子树的高度

树-二叉平衡树AVL

基本概念 AVL树:树中任何节点的两个子树的高度最大差别为1. AVL树的查找.插入和删除在平均和最坏情况下都是O(logn). AVL实现 AVL树的节点包括的几个组成对象: (01) key -- 是关键字,是用来对AVL树的节点进行排序的. (02) left -- 是左孩子. (03) right -- 是右孩子. (04) height -- 是高度.即空的二叉树的高度是0,非空树的高度等于它的最大层次(根的层次为1,根的子节点为第2层,依次类推). AVL旋转算法 AVL失衡四种形态

二叉树--二叉平衡树

二叉平衡树是二叉树中最为最要的概念之一,也是在语言库或者项目中应用比较广泛的一种特殊的树形结构. 二叉平衡树 AVL树是高度平衡的而二叉树.它的特点是:AVL树中任何节点的两个子树的高度最大差别为1. 通常AVL树是在二叉搜索树上,经过局部调整而建立的,因此,它还是一棵排序树. 上面的两张图片,左边的是AVL树,它的任何节点的两个子树的高度差别都<=1:而右边的不是AVL树,因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3,而以8为根节点的树的高度是1). 性质 左右子树相差不超过1.

二叉平衡树的插入和删除操作

1.      二叉平衡树 二叉排序树的时间复杂度和树的深度n有关.当先后插入的结点按关键字有序时,二叉排序树退化为单枝树,平均查找长度为(n+1)/2,查找效率比较低.提高查找效率,关键在于最大限度地降低树的深度n.因此需要在构成二叉排序树的过程中进行“平衡化”处理,使之成为二叉平衡树. 二叉平衡树,又称AVL树.它或者是一棵空树,或者是具有下列性质的树: 1)      具备二叉排序树的所有性质: 2)      左子树和右子树深度差的绝对值不超过1: 3)      左子树和右子树都是二叉

二叉平衡树之删除节点

二叉平衡树之删除节点操作 更好的判断最小非平衡树类型的方法 在前一篇文章中,我们知道最小非平衡树可以分为四种类型,即:LL型.LR型.RR型和RL型.而且我也按照自己的理解,归纳了判断是哪种类型的方法.总结一下就是:设最小非平衡树的树根为unbalance,首先看unbalance的左右子树谁更高,如果左子树更高则为LX型.如果是右子树高则为RX型.再进一步,如果为LX型,将刚刚插入的节点的值value与unbalance左孩子进行比较,如果value大则为LR型,如果value小则为LL型.如

二叉树遍历的应用(路径和问题,判断是否是二叉搜索树,判断是否是二叉平衡树)

现在越发觉得关于树的问题真是千变万化,随便改一个条件又会是一个新的问题. 先序遍历求二叉树路径问题 问题:一棵二叉树每个节点包含一个整数,请设计一个算法输出所有满足条件的路径:此路径上所有节点之和等于给定值.注意此类路径不要求必须从根节点开始. 如果没有最后一个条件,这道题在leetcode上面见过,就是采取先序遍历的方式并记录下路径.但是加上最后一个条件后需要转下弯思考一下. 当然也需要记录下路径,并且记得要回溯.加上不要求从根节点开始这个条件后可以这么思考,每次遍历到当前节点时,从路径中查找

如何将Java项目转换为Java Web项目?

上一篇文章讲了"如何将Java Web项目转换为Java项目?"这里就介绍一下如何将Java项目转换为Java Web项目. 在项目名称上单击鼠标右键>Properties>Project Facets 刚打开Utility Module是锁定的,需要解锁后其它选项才能显示出来. 显示出来之后,选中图中对应的项,Utility Module应该是没什么用的,取消选中,应用(Apply)就好了.

Maven—如何使用maven命令创建Java项目或Java Web项目

博客<Maven-Windows操作系统中安装配置Maven环境>介绍了如何在Windows操作系统中安装配置Maven,现总结一下如何借助maven命令创建Java项目或Java Web项目: 1.借助maven命令创建Java项目: 1.借助maven命令创建Java Web项目:

eclipse如何为java项目生成java Doc

eclipse如何为java项目生成java Doc 1.编写 2.生成 next  >>>>finish 原文地址:https://www.cnblogs.com/star521/p/8761490.html