D13-平衡二叉树[Java数据结构和算法]

Posted 2022-08-04 erfishing

1.平衡二叉树基本介绍

　　1.1平衡二叉树又叫平衡二叉搜索树(Selg-balancing binary search tree)，又叫AVL树，可以保证查询效率较高；

　　1.2 平衡二叉树是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是平衡二叉树。

　　1.3 平衡二叉树的常用实现方法有红黑树，AVL，替罪羊树，Treap，伸展树等；

 

2. AVL左旋转

　　2.1 左旋转流程（右子树的高度高）

　　2.2 右旋转流程（左子树的高度高）

　　2.3 双旋转，存在以下的情况不能单单进行一方旋转

　　2.4 代码实现

  1 package cn.atguigu.AVL;
  2 
  3 
  4 public class AVLTreeDemo 
  5 
  6     public static void main(String[] args) 
  7 //        int[] arr= 4,3,6,5,7,8;
  8 //        int[] arr= 10,12,8,9,7,6;
  9         int[] arr= 10,11,7,6,8,9;
 10         //创建AVLTree对象
 11         AVLTree avlTree=new AVLTree();
 12         //添加节点
 13         for (int i = 0; i < arr.length; i++) 
 14             avlTree.add(new Node(arr[i]));
 15         
 16         
 17         //遍历
 18         System.out.println("中序遍历");
 19         avlTree.infixOrder();
 20         
 21         System.out.println("做平衡处理");
 22         System.out.println("left树的高度="+avlTree.getRoot().leftHeight());
 23         System.out.println("right树的高度="+avlTree.getRoot().rightHeight());
 24     
 25 
 26 
 27 
 28 //创建AVL树
 29 class AVLTree 
 30     private Node root;
 31 
 32     public Node getRoot() 
 33         return root;
 34     
 35 
 36     // 查找要删除的节点
 37     public Node search(int value) 
 38         if (root == null) 
 39             return null;
 40          else 
 41             return root.search(value);
 42         
 43     
 44 
 45     // 查找要删除节点的父节点
 46     public Node searchParent(int value) 
 47         if (root == null) 
 48             return root;
 49          else 
 50             return root.searchParent(value);
 51         
 52     
 53 
 54     /**
 55      * 1.返回以node为根节点的二叉排序树的最小节点的值 2.删除以node为根节点的二叉排序树的最小节点的值
 56      * 
 57      * @param node 传入的节点，当作二叉排序树的根节点
 58      * @return 返回以node为根节点的二叉排序树的最小节点的值
 59      */
 60     public int delRightTreeMin(Node node) 
 61         Node target = node;
 62         // 循环查找的左节点，会找到最小值
 63         while (target.left != null) 
 64             target = target.left;
 65         
 66         // 这是target指向了最小节点
 67         // 删除最小节点
 68         delNode(target.value);
 69         return target.value;
 70     
 71 
 72     // 删除节点
 73     public void delNode(int value) 
 74 
 75         if (root == null) 
 76             return;
 77          else 
 78             // 找到要删除的节点targetNode;
 79             Node targetNode = root.search(value);
 80             if (targetNode == null)
 81                 return;// 如果没有找到该接待你
 82             // 如果当前这颗二叉排序树只有一个节点
 83             if (root.left == null && root.right == null) 
 84                 root = null;
 85                 return;
 86             
 87             // 找到targetNode的父节点
 88             Node parent = root.searchParent(value);
 89             // 如果删除的节点是叶子节点
 90             if (targetNode.left == null && targetNode.right == null) 
 91                 if (parent.left != null && parent.left.value == value) // 判断targetNode是父节点的左子节点还是右子节点
 92                     parent.left = null;
 93                  else if (parent.right != null && parent.right.value == value) // 是右子节点
 94                     parent.right = null;
 95                 
 96              else if (targetNode.left != null && targetNode.right != null) // targetNode有左子树和右子树
 97                 int minVal = delRightTreeMin(targetNode.right);
 98                 targetNode.value = minVal;
 99              else // 删除只有一颗子树的节点
100                     // 如果要删除的节点有左子节点
101                 if (targetNode.left != null) 
102                     if (parent != null) 
103                         if (parent.left.value == value) // targetNode是parent的左子节点
104                             parent.left = targetNode.left;
105                          else // targetNode是parent的右子节点
106                             parent.right = targetNode.left;
107                         
108                      else 
109                         root = targetNode.left;
110                     
111                  else 
112                     if (parent != null) 
113                         // 如果要删除的节点有右子节点
114                         if (parent.left.value == value) // targetNode是parent的左子节点
115                             parent.left = targetNode.right;
116                          else // targetNode是parent的右子节点
117                             parent.right = targetNode.right;
118                         
119                      else 
120                         root = targetNode.right;
121                     
122 
123                 
124             
125         
126     
127     
128     // 添加节点的方法
129         public void add(Node node) 
130             if (root == null) 
131                 root = node;// 如果root为空，直接让root指向node
132              else 
133                 root.add(node);
134             
135         
136 
137         // 重载
138         public void infixOrder() 
139             this.infixOrder(root);
140         
141 
142         // 中序遍历方法
143         public void infixOrder(Node root) 
144             if (root == null) 
145                 System.out.println("树为空，无法遍历");
146              else 
147                 root.infixOrder();
148             
149         
150 
151 //创建NOde节点
152 class Node 
153     int value;
154     Node left;
155     Node right;
156     public Node(int value) 
157         this.value = value;
158     
159     //返回左子树的高度
160     public int leftHeight() 
161         if(left==null) 
162             return 0;
163         
164         return left.height();
165     
166     //返回右子树的高度
167     public int rightHeight() 
168         if(right==null) 
169             return 0;
170         
171         return right.height();
172     
173     //返回当前节点的高度,以该节点为树的高度
174     public int height() 
175         return Math.max(left==null? 0:left.height(), right==null? 0:right.height())+1;
176     
177     
178     @Override
179     public String toString() 
180         return "Node [value=" + value + "]";
181     
182     
183     //右旋转
184     private void rightRotate() 
185         Node newNode=new Node(value);
186         newNode.right=right;
187         newNode.left=left.right;
188         value=left.value;
189         left=left.left;
190         right=newNode;
191     
192     
193     //左旋转方法
194     private void leftRotate() 
195         //创建新的节点，以当前根节点的值
196         Node newNode=new Node(value);
197         //把新的节点的左子树设置成当前节点的左子树
198         newNode.left=left;
199         //把新的节点的右子树设置成当前节点的右子树的左子树
200         newNode.right=right.left;
201         //把当前节点的值替换成右子树的值
202         newNode.value=right.value;
203         //把当前节点的右子树设置成当前节点的右子树的右子树
204         right=right.right;
205         //把当前节点的左子树设置成新的节点
206         left=newNode;    
207     
208     // 查找要删除的节点
209     /**
210      * 
211      * @param value 希望删除的节点的值
212      * @return 找到返回，没有返回null
213      */
214     public Node search(int value) 
215         if (value == this.value) 
216             return this;
217          else if (value < this.value) // 如果查找的值小于当前节点，向左子树递归查找
218             if (this.left == null) 
219                 return null;
220             
221             return this.left.search(value);
222          else // 如果查找的值不小于当前节点，向右子树递归查找
223             if (this.right == null) 
224                 return null;
225             
226             return this.right.search(value);
227         
228     
229 
230     // 查找要删除节点的父节点
231     /**
232      * 
233      * @param value 要找到的节点的值
234      * @return 找到返回的是要删除节点的父节点的值，否则返回null
235      */
236     public Node searchParent(int value) 
237         // 如果当前节点是要删除节点的父节点，就返回
238         if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) 
239             return this;
240          else 
241             // 如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
242             if (value < this.value && this.left != null) 
243                 return this.left.searchParent(value);// 向左子树递归查找
244              else if (value >= this.value && this.right != null) 
245                 return this.right.searchParent(value);// 向右子树递归查找
246              else 
247                 return null;// 没有找到父节点
248             
249         
250     
251 
252     // 添加节点的方法
253     // 递归的形式添加节点，注意需要满足二叉排序树的要求
254     public void add(Node node) 
255         if (node == null) 
256             return;
257         
258         // 判断传入的节点的值，和当前子树的根节点的值关系
259         if (node.value < this.value) 
260             // 如果当前节点的左子节点为null
261             if (this.left == null) 
262                 this.left = node;
263              else // 递归向左子树添加
264                 this.left.add(node);
265             
266          else 
267             // 如果当前节点的右子节点为null
268             if (this.right == null) 
269                 this.right = node;
270              else // 递归向右子树添加
271                 this.right.add(node);
272             
273         
274         //当添加完一个节点后，如果：右子树的高度-左子树的高度>1，左旋转
275         if(rightHeight()-leftHeight()>1) 
276             //如果它的右子树的左子树的高度大于它的右子树的高度
277             if(right!=null&&right.leftHeight()>right.rightHeight()) 
278                 //先对右子节点进行右旋转
279                 right.rightRotate();
280                 //再对当前节点进行左旋转
281                 leftRotate();
282             else 
283                 leftRotate();                
284             
285             return;//必须要
286         
287         //当添加完一个节点后，如果：左子树的高度-右子树的高度>1，右旋转
288         if(leftHeight()-rightHeight()>1) 
289             //如果它的左子树的右子树的高度大于它的左子树的高度
290             if(left!=null && left.rightHeight()>left.leftHeight()) 
291                 //先对当前节点的左节点进行左旋转
292                 left.leftRotate();
293                 //再对当前节点进行右旋转
294                 rightRotate();
295             else 
296                 rightRotate();                
297             
298         
299     
300     
301     // 中序遍历二叉树
302     public void infixOrder() 
303         if (this.left != null) 
304             this.left.infixOrder();
305         
306         System.out.println(this);
307         if (this.right != null) 
308             this.right.infixOrder();
309         
310     
311