平衡二叉树(AVL树)

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();
		}
	}
	
}