4.5 平衡二叉树

功能

1. 实现了左旋转，右旋转
2. 实现了查看树的高度的方法
3. 实现了创建一棵平衡二叉树的方法

代码

/**
 * AVL树：平衡二叉树 也被称为 平衡二叉搜索树，
 * 目的：保证较高的查询效率,方便查询搜索
 * 特点：它是一棵空树 或 它的左右两棵子树的高度差的绝对值不超过1，并且左右两棵子树都是一棵平衡二叉树。
 * 实现：
 * 	 构建一棵平衡二叉树
 * 	  (1) 左旋转：右子树高度大于左子树
 *    (2) 右旋转：左子树高度大于右子树
 *    注意：一些条件下，需要进行两次旋转！！！！！！（双旋转）
 * @author dxt
 *
 */
public class AVLTreeDemo {
	public static void main(String[] args) {
		//int[] arr = {4, 3, 6, 5, 7, 8};
		//int[] arr = {10, 12, 8, 9, 7, 6};
		int[] arr = {6, 7, 8, 9, 10, 11};
		
		//1. 创建一棵AVL树
		AVLTree avltree = new AVLTree();
		for(int i=0; i<arr.length; i++) {
			avltree.add(new Node(arr[i]));
		}
		
		//2. 遍历
		System.out.println("前序遍历：");
		avltree.preOrder();
		System.out.println("中序遍历：");
		avltree.infixOrder();
		System.out.println("前序绘制");
		avltree.preDraw();
		
		//3. 查看树的高度
		System.out.println("树的高度：" + avltree.getRoot().height());
		System.out.println("左子树的高度：" + avltree.getRoot().leftHeight());
		System.out.println("右子树的高度：" + avltree.getRoot().rightHeight());
		
	}
}

class AVLTree{
	private Node root;
	
	public AVLTree() {}
	public AVLTree(Node root) {
		this.root = root;
	}
	public Node getRoot() {
		return root;
	}
	
	public void add(Node node) {
		if(root == null) {
			root = node;
		}else {
			root.add(node);
		}	
	}
	
	//前序遍历
	public void preOrder() {
		if(root == null) {
			System.out.println("AVL树为空。。。");
			return;
		}else {
			this.root.preOrder();
		}
	}
	//中序遍历
	public void infixOrder() {
		if(root == null) {
			System.out.println("AVL树为空。。。");
		}
		this.root.infixOrder();
	}
	//前序绘制树形结构
	public void preDraw() {
		if(this.root == null) {
			System.out.println("AVL树为空。。。");
		}
		this.root.preDraw(1); 	//根节点在第一层
	}
}

class Node{
	int value;
	Node left;
	Node right;
	
	public Node() {}
	public Node(int value) {
		this.value = value;
	}
	
	/**
	 * 左旋转
	 * 用途： 当向AVL树添加一个节点时，此节点的添加造成树的 右子树高度 大于 左子树高度，导致AVL树的条件
	 * 		被破坏，此时使用左旋转
	 * 算法：
	 * 	 （1）创建一个新的节点，新节点的值为当前结点的值
	 *   （2）将新的节点的左子树 设置 为当前节点的左子树
	 *   （3）将新的节点的右子树设置为当前节点右子树的左子树
	 *   （4）将当前节点的值设置为当前节点右子节点的值
	 *   （5）将当前节点的右子树 设置成 当前节点右子树的的右子树
	 *   （6）将当前节点的左子树（左子节点） 设置成 新的节点
	 */
	public void leftRotate() {
		//1. 创建一个新的节点，新节点的值为当前AVL树的根结点的值
		Node newNode = new Node(this.value);
		//2. 将新的节点的左子树 设置为 当前节点的左子树
		newNode.left = this.left;
		//3. 将新的节点的右子树设置为当前节点的右子树的左子树
		newNode.right = this.right.left;
		//4. 将当前节点的值 设置为 当前节点右子节点的值
		this.value = this.right.value;
		//5. 将当前节点的右子树 设置成 当前节点右子树的的右子树
		this.right = this.right.right;
		//6. 将当前节点的左子树（左子节点） 设置成 新的节点
		this.left = newNode;
	}
	
	/**
	 * 右旋转
	 * 用途： 当左子树的高度大于右子树的高度，导致AVL树的条件被破坏
	 * 算法：
	 *   （1）创建一个新节点，设置新节点的值为当前节点的值
	 *   （2）将新节点的左子树设置为当前节点左子树的右子树
	 *   （3）将新节点的右子树设置为当前节点的右子树
	 *   （4）将当前节点的值设置为当前节点左子节点的值
	 *   （5）将当前节点的左子树（左子节点） 设置为 当前节点的左子节点的左子节点
	 *   （6）将当前节点的右子树（右子节点） 设置为 新节点
	 */
	public void rightRotate() {
		//1. 
		Node newNode = new Node(this.value);
		//2. 
		newNode.left = this.left.right;
		//3. 
		newNode.right = this.right;
		//4. 
		this.value = this.left.value;
		//5. 
		this.left = this.left.left;
		//6. 
		this.right = newNode;
	}
	
	
	//递归像树中添加节点
	public void add(Node node) {
		//1. 传入的参数是否合法
		if(node == null) {
			return;
		}
		
		//2. 递归添加节点
		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);
			}
		}
		
		//3.1 当添加完一个节点后，如果： 右子树的高度 - 左子树的高度 > 1, 则进行 左旋转
		if((this.rightHeight() - this.leftHeight()) > 1) {
			//当前节点： 右子树的高度 - 左子树的高度 > 1, 则进行 左旋转
			//如果当前节点的 右子树的左子树的高度 大于 右子树的右子树的高度
			if(this.right != null && this.right.leftHeight() > this.right.rightHeight()) {
				//则先对 右子树进行右旋转，然后在对当前节点进行左旋转
				this.right.rightRotate();	//右子树 右旋转
				this.leftRotate();			//左旋转
			}else {
				this.leftRotate();
			}
			
			return;	//注意！！！
		}
		//3.2 当添加完一个节点后，如果： 左子树的高度 - 右子树的高度 > 1, 则进行 右旋转
		if((this.leftHeight() - this.rightHeight()) > 1) {
			//当前节点： 左子树的高度 - 右子树的高度 > 1
			//如果当前节点 左子树的右子树的高度 大于 左子树的左子树的高度
			if(this.left != null && this.left.rightHeight() > this.left.leftHeight()) {
				//则先对左子树进行 右旋转， 然后在对当前节点进行左旋转
				this.left.rightRotate();
				this.leftRotate();
			}else {
				this.rightRotate();
			}
			
		}
	}
	
	//返回左子树的高度
	public int leftHeight() {
		if(this.left == null) {
			return 0;
		}
		return this.left.height();
	}
	
	//返回右子树的高度
	public int rightHeight() {
		if(this.right == null) {
			return 0;
		}
		return this.right.height();
	}
	
	//获取以当前节点为根节点的树的高度
	public int height() {
		return Math.max(this.left == null ? 0 : this.left.height(), 
				this.right == null ? 0 : this.right.height()) + 1;
	}
	
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
	//中序遍历
	public void infixOrder() {
		if(this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
	//前序树形结构输出
	public void preDraw(int level) {
		System.out.println(this.value);
		//绘制左子树
		if(this.left != null) {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			this.left.preDraw(level+1);
		}else {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			System.out.println("null");
		}
		//绘制右子树
		if(this.right != null) {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			this.right.preDraw(level+1);
		}else {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			System.out.println("null");
		}
	}
	
	@Override
	public String toString() {
		return "Node : "+this.value;
	}
}

结果

总结

      旋转一共有四种情况，在学习时分别画个图会好很多。