1)平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树, 可以保证查询效率较高。
2)具有以下特点:它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。
1)给你一个数列,创建出对应的平衡二叉树.数列 {4,3,6,5,7,8}单旋转(左旋转)
2)给你一个数列,创建出对应的平衡二叉树.数列 {10,12, 8, 9, 7, 6}
单旋转(右旋转)
前面的两个数列,进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但是在某些情况下,单旋转不能完成平衡二叉树的转换。比如数列
int[] arr = { 10, 11, 7, 6, 8, 9 }; 运行原来的代码可以看到,并没有转成 AVL树.
问题分析出来: 在满足右旋转条件时,要判断
(1)如果 是 左子树的 右子树高度 大于左子树的左子树时:
(2)就是 对 当前根节点的左子树,先进行 左旋转,
(3)然后, 在对当前根节点进行右旋转即可
package AVLTree;
public class AVLTree {
public static void main(String[] args) {
int[] arr={10,11, 8, 9, 7, 6};
Tree tree = new Tree();
for (int i = 0; i < arr.length; i++) {
tree.add(new Node(arr[i]));
}
System.out.println("中序遍历");
tree.midOrder();
System.out.println("没有平衡处理前的树高度:"+tree.getRoot().height());
System.out.println("左子树高度:"+tree.getRoot().leftheight());
System.out.println("右子树高度:"+tree.getRoot().rightheight());
System.out.println("当前的根节点"+tree.getRoot());
System.out.println("当前的根节点的左子节点"+tree.getRoot().left);
System.out.println("当前的根节点的右子节点"+tree.getRoot().right);
}
}
//创建二叉平衡树
class Tree{
private Node root;
public Node getRoot() {
return root;
}
//添加节点
public void add(Node node) {
if (root == null) {
root = node;
}else {
root.add(node);
}
}
//中序遍历
public void midOrder() {
if (root != null) {
root.midOrder();
}else {
System.out.println("空");
}
}
}
class Node{
int value;
Node left;
Node right;
public Node(int value) {
super();
this.value = value;
}
//返回以当前节点为根节点的数的高度
public int height() {
return Math.max(left==null?0:left.height(),right==null ? 0 : right.height())+1;
}
//返回左子树的高度
public int leftheight() {
if (left == null) {
return 0;
}
return left.height();
}
//返回右子树的高度
public int rightheight() {
if (right == null) {
return 0;
}
return right.height();
}
//左旋转
public void leftRotate() {
//创建新的节点保存当前根结点的值
Node newNode = new Node(value);
//把新的结点的左子树设置成当前结点的左子树
newNode.left = left;
//把新的结点的右子树设置成带你过去结点的右子树的左子树
newNode.right = right.left;
//把当前结点的值替换成右子结点的值
value = right.value;
//把当前结点的右子树设置成当前结点右子树的右子树
right = right.right;
//把当前结点的左子树(左子结点)设置成新的结点
left = newNode;
}
//右旋转
public void rightRotate() {
//创建新的节点保存当前根结点的值
Node newNode = new Node(value);
//把新节点的右子树设置了当前节点的右子树
newNode.right = right;
//把新节点的左子树设置为当前节点的左子树的右子树
newNode.left =left.right;
把当前节点的值换为左子节点的值
value=left.value;
//把当前节点的左子树设置成左子树的左子树
left=left.left;
把当前节点的右子树设置为新节点
right=newNode;
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
//递归添加节点
public void add(Node node) {
if (node == null) {
return;
}
//判断传入节点和当前节点的值关系,小于放在左子树,否则放在右子树
if (node.value<this.value) {
//左子树为空则直接放入
if (this.left == null) {
this.left = node;
}else {
//不为空则递归放入
this.left.add(node);;
}
}else {
if (this.right == null) {
this.right = node;
}else {
this.right.add(node);;
}
}
//添加完一个节点后判断(右子树高度-左子树高度)>1,左旋转
if (rightheight()-leftheight()>1) {
//如果它的右子树的左子树高度大于右子树的高度,需要进行一次右旋转,才能左旋转
if (right!=null&&right.leftheight()>right.rightheight()) {
rightRotate();
}
leftRotate();
return;//!!!
}
//添加完一个节点后判断(左子树高度-右子树高度)>1,右旋转
if (leftheight()-rightheight()>1) {
//如果它的左子树的右子树高度大于左子树的高度,需要进行一次左旋转,才能右旋转
if (left!=null&&left.rightheight()>left.leftheight()) {
leftRotate();
}
rightRotate();
return;//!!!
}
}
//中序遍历
public void midOrder() {
if (this.left != null) {
this.left.midOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.midOrder();
}
}
}