Java数据结构与算法 day10 树结构实际应用(三)

文章目录

• 第10章 树结构的实际应用
• 二叉排序树
• 二叉排序树(BST)的介绍
• 二叉排序树(BST)创建和遍历
• 二叉排序树删除结点思路图解
• 二叉排序树删除叶子结点
• BST删除有一颗子树的结点
• BST删除有二颗子树的结点
• 平衡二叉树(AVL树)
• 平衡二叉树(AVL树)介绍
• AVL树左旋转思路图解
• AVL树高度求解
• AVL树左旋转代码实现
• AVL树右旋转图解和实现
• AVL树双旋转图解和实现
• 本章思维导图

第10章 树结构的实际应用

本章源码：https://github.com/name365/Java-Data-structure

二叉排序树

二叉排序树(BST)的介绍

先看一个需求：

• 给你一个数列 (7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加。

解决方案分析：

• 使用数组

  • 数组未排序， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢.
  • 数组排序，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序，在添加新数据时，找到插入位置后，后面的数据需整体移动，速度慢。

• 使用链式存储-链表
  不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。
• 使用二叉排序树

二叉排序树介绍：

• 二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

• 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点

• 比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：

二叉排序树(BST)创建和遍历

一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树，比如: 数组为 Array(7, 3, 10, 12, 5, 1, 9) ， 创建成对应的二叉排序树为 :

public class BinarySortTreeTest {

	public static void main(String[] args) {
		int arr[] = {7,3,10,12,5,1,9};
		BinaryTree tree = new BinaryTree();
		//循环的添加结点到二叉排序树
		for(int i = 0 ;i< arr.length;i++){
			tree.add(new Node(arr[i]));
		}
		
		//中序遍历二叉排序树
		System.out.println("中序遍历此树:");
		tree.infixOrder(); 	//1,3,5,7,9,10,12
	}

}

//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
}

//创建二叉排序树
class BinaryTree{
	private Node root;
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
}

二叉排序树删除结点思路图解

二叉排序树的删除情况比较复杂，有下面三种情况需要考虑

1)删除叶子节点 (比如：2, 5, 9, 12)

2)删除只有一颗子树的节点 (比如：1)

3)删除有两颗子树的节点. (比如：7, 3，10 )

二叉排序树删除叶子结点

图解 二叉排序树 删除结点的 三种情况

第一种情况: 删除叶子节点 (比如：2, 5, 9, 12)
思路
(1) 需求先去找到要删除的结点  targetNode
(2) 找到targetNode 的 父结点 parent 
(3) 确定 targetNode 是 parent的左子结点 还是右子结点
(4) 根据前面的情况来对应删除
	左子结点 parent.left = null
	右子结点 parent.right = null;

代码实现如下:

public class BinarySortTreeTest {

	public static void main(String[] args) {
		int arr[] = {7,3,10,12,5,1,9};
		BinaryTree tree = new BinaryTree();
		//循环的添加结点到二叉排序树
		for(int i = 0 ;i< arr.length;i++){
			tree.add(new Node(arr[i]));
		}
		
		//中序遍历二叉排序树
		System.out.println("中序遍历此树:");
		tree.infixOrder(); 	//1,3,5,7,9,10,12
		
		//测试一下删除叶子节点
		tree.delNode(2);
		tree.delNode(5);
		tree.delNode(9);
		System.out.println("删除后的节点:");
		tree.infixOrder();
	}

}

//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
	
	//查找要删除的节点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午8:43:01
	  * @param value 希望删除的结点的值
	  * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value){
		if(value == this.value){	//说明找到了
			return this;
		}else if(value < this.value){	//查找的值小于当前结点的值,向左子树查找
			if(this.left == null){	//左子结点为空
				return null;
			}
			return this.left.search(value);
		}else{	//查找的值不小于当前结点的值,向右子树查找
			if(this.right == null){
				return null;
			}
			return this.right.search(value);
		}
	}
	

	//查找要删除结点的父结点
	/**
	 * 
	 * @param value 希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value){
		//如果当前结点是要删除的结点的父结点,如果没有就返回null
		if((this.left != null && this.left.value == value)||
				(this.right != null && this.right.value == value)){
			return this;
		}else{
			//如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if(value < this.value && this.left != null){
				return this.left.searchP(value);	//向左子树查找
			}else if(value >= this.value && this.right != null){
				return this.right.searchP(value);	//向右子树递归查找
			}else {
				return null;	//未找到父结点
			}
		}
	}
	
}

//创建二叉排序树
class BinaryTree{
	private Node root;
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
	//查找要刪除的结点
	public Node search(int value){
		if(root == null){
			return null;
		}else{
			return root.search(value);
		}
	}
	//查找要删除的节点的父节点
	public Node searchP(int value){
		if(root == null){
			return null;
		}else{
			return root.searchP(value);
		}
	}
	
	//删除节点
	public void delNode(int value){
		if(root == null){
			return;
		}else{
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode ==null){
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}
			//去找到targetNode的父结点
			Node parent = searchP(value);
			//如果要删除的节点为叶子节点
			if(targetNode.left == null && targetNode.right == null){
				//判断targetNode是父节点的左子结点,还是右子节点
				if(parent.left != null && parent.left.value == value){	//左子节点
					parent.left = null;
				}else if(parent.right != null && parent.right.value == value){	//右子节点
					parent.right = null;
				}
			}
		}
	}
}

---

BST删除有一颗子树的结点

第二种情况: 删除只有一颗子树的节点 比如 1
思路
(1) 需求先去找到要删除的结点  targetNode
(2) 找到targetNode 的 父结点 parent 
(3) 确定targetNode 的子结点是左子结点还是右子结点
(4) targetNode 是 parent 的左子结点还是右子结点
(5) 如果targetNode 有左子结点
	5.1 如果 targetNode 是 parent 的左子结点
		parent.left = targetNode.left;
	5.2 如果 targetNode 是 parent 的右子结点
		parent.right = targetNode.left;
(6) 如果targetNode 有右子结点
	6.1 如果 targetNode 是 parent 的左子结点
		parent.left = targetNode.right;
	6.2 如果 targetNode 是 parent 的右子结点
		parent.right = targetNode.right

代码实现如下:

public class BinarySortTreeTest {

	public static void main(String[] args) {
		int arr[] = {7,3,10,12,5,1,9,0};
		BinaryTree tree = new BinaryTree();
		//循环的添加结点到二叉排序树
		for(int i = 0 ;i< arr.length;i++){
			tree.add(new Node(arr[i]));
		}
		
		//中序遍历二叉排序树
		System.out.println("中序遍历此树:");
		tree.infixOrder(); 	//0,1,3,5,7,9,10,12
		
		//测试一下删除叶子节点
		tree.delNode(1);
		System.out.println("删除后的节点:");
		tree.infixOrder();	//0,3,5,7,9,10,12
	}

}

//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
	
	//查找要删除的节点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午8:43:01
	  * @param value 希望删除的结点的值
	  * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value){
		if(value == this.value){	//说明找到了
			return this;
		}else if(value < this.value){	//查找的值小于当前结点的值,向左子树查找
			if(this.left == null){	//左子结点为空
				return null;
			}
			return this.left.search(value);
		}else{	//查找的值不小于当前结点的值,向右子树查找
			if(this.right == null){
				return null;
			}
			return this.right.search(value);
		}
	}
	

	//查找要删除结点的父结点
	/**
	 * 
	 * @param value 希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value){
		//如果当前结点是要删除的结点的父结点,如果没有就返回null
		if((this.left != null && this.left.value == value)||
				(this.right != null && this.right.value == value)){
			return this;
		}else{
			//如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if(value < this.value && this.left != null){
				return this.left.searchP(value);	//向左子树查找
			}else if(value >= this.value && this.right != null){
				return this.right.searchP(value);	//向右子树递归查找
			}else {
				return null;	//未找到父结点
			}
		}
	}
	
	
}

//创建二叉排序树
class BinaryTree{
	private Node root;
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
	//查找要刪除的结点
	public Node search(int value){
		if(root == null){
			return null;
		}else{
			return root.search(value);
		}
	}
	//查找要删除的节点的父节点
	public Node searchP(int value){
		if(root == null){
			return null;
		}else{
			return root.searchP(value);
		}
	}
	
	//删除节点
	public void delNode(int value){
		if(root == null){
			return;
		}else{
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode ==null){
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}
			//去找到targetNode的父结点
			Node parent = searchP(value);
			//如果要删除的节点为叶子节点
			if(targetNode.left == null && targetNode.right == null){
				//判断targetNode是父节点的左子结点,还是右子节点
				if(parent.left != null && parent.left.value == value){	//左子节点
					parent.left = null;
				}else if(parent.right != null && parent.right.value == value){	//右子节点
					parent.right = null;
				}
			}else if(targetNode.left != null && targetNode.right != null){	//删除有两颗子树的节点
				
			}else{	//删除只有一个字树的节点
				//如果要删除的结点有左子结点 
				if(targetNode.left != null) {
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.left;
						} else {	//targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						} 
					} else {
						root = targetNode.left;
					}
				}else{	//如果要删除的结点有右子结点 
					if(parent != null){
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value){
							parent.left = targetNode.right;
						}else{	//如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					}else{
						root = targetNode.right;
					}
				}
			}
		}
	}
}

---

BST删除有二颗子树的结点

情况三: 删除有两颗子树的节点. (比如：7, 3，10 )
思路
(1) 需求先去找到要删除的结点  targetNode
(2) 找到targetNode 的 父结点 parent 
(3) 从targetNode 的右子树找到最小的结点
(4) 用一个临时变量，将 最小结点的值保存 temp = 11
(5) 删除该最小结点
(6) targetNode.value = temp

代码实现如下:

public class BinarySortTreeTest {

	public static void main(String[] args) {
		int arr[] = {7,3,10,12,5,1,9,0};
		BinaryTree tree = new BinaryTree();
		//循环的添加结点到二叉排序树
		for(int i = 0 ;i< arr.length;i++){
			tree.add(new Node(arr[i]));
		}
		
		//中序遍历二叉排序树
		System.out.println("中序遍历此树:");
		tree.infixOrder(); 	//0,1,3,5,7,9,10,12
		
		//测试一下删除叶子节点
		tree.delNode(7);
		System.out.println("删除后的节点:");
		tree.infixOrder();	//0,1,3,5,9,10,12
	}

}

//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
	
	//查找要删除的节点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午8:43:01
	  * @param value 希望删除的结点的值
	  * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value){
		if(value == this.value){	//说明找到了
			return this;
		}else if(value < this.value){	//查找的值小于当前结点的值,向左子树查找
			if(this.left == null){	//左子结点为空
				return null;
			}
			return this.left.search(value);
		}else{	//查找的值不小于当前结点的值,向右子树查找
			if(this.right == null){
				return null;
			}
			return this.right.search(value);
		}
	}
	

	//查找要删除结点的父结点
	/**
	 * 
	 * @param value 希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value){
		//如果当前结点是要删除的结点的父结点,如果没有就返回null
		if((this.left != null && this.left.value == value)||
				(this.right != null && this.right.value == value)){
			return this;
		}else{
			//如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if(value < this.value && this.left != null){
				return this.left.searchP(value);	//向左子树查找
			}else if(value >= this.value && this.right != null){
				return this.right.searchP(value);	//向右子树递归查找
			}else {
				return null;	//未找到父结点
			}
		}
	}
	
	
}

//创建二叉排序树
class BinaryTree{
	private Node root;
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
	//查找要刪除的结点
	public Node search(int value){
		if(root == null){
			return null;
		}else{
			return root.search(value);
		}
	}
	//查找要删除的节点的父节点
	public Node searchP(int value){
		if(root == null){
			return null;
		}else{
			return root.searchP(value);
		}
	}
	
	//删除节点
	public void delNode(int value){
		if(root == null){
			return;
		}else{
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode ==null){
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}
			//去找到targetNode的父结点
			Node parent = searchP(value);
			//如果要删除的节点为叶子节点
			if(targetNode.left == null && targetNode.right == null){
				//判断targetNode是父节点的左子结点,还是右子节点
				if(parent.left != null && parent.left.value == value){	//左子节点
					parent.left = null;
				}else if(parent.right != null && parent.right.value == value){	//右子节点
					parent.right = null;
				}
			}else if(targetNode.left != null && targetNode.right != null){	//删除有两颗子树的节点
				int minVa = delRightT(targetNode.right);
				targetNode.value = minVa;
			}else{	//删除只有一个字树的节点
				//如果要删除的结点有左子结点 
				if(targetNode.left != null) {
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.left;
						} else {	//targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						} 
					} else {
						root = targetNode.left;
					}
				}else{	//如果要删除的结点有右子结点 
					if(parent != null){
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value){
							parent.left = targetNode.right;
						}else{	//如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					}else{
						root = targetNode.right;
					}
				}
			}
		}
	}
	
	//编写方法
	//1.返回的 以node 为根结点的二叉排序树的最小结点的值
	//2.删除node 为根结点的二叉排序树的最小结点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午10:44:31
	  * @param node 传入的结点(为二叉排序树的根结点)
	  * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node){
		Node tar = node;
		//循环的查找左子节点，就会找到最小值
		while(tar.left != null){
			tar = tar.left;
		}
		//这时 target就指向了最小结点
		//删除最小结点
		delNode(tar.value);
		return tar.value;
	}
}

---

从左子树找到最大的结点，然后删除节点

思路
看过上面的或者已经有相关数据结构的道友就会了解，实现起来异常简单。
    1.最小值就是二叉树最左边的叶子节点；
    2.而最大值就是二叉树最左边的叶子节点。

public class BinarySortTreeTest {

	public static void main(String[] args) {
		int arr[] = {7,3,10,12,5,1,9,2};
		BinaryTree tree = new BinaryTree();
		//循环的添加结点到二叉排序树
		for(int i = 0 ;i< arr.length;i++){
			tree.add(new Node(arr[i]));
		}
		
		//中序遍历二叉排序树
		System.out.println("中序遍历此树:");
		tree.infixOrder(); 	//1,2,3,5,7,9,10,12
		
		//测试一下删除叶子节点
		tree.delNode(10);
		System.out.println("删除后的节点:");
		tree.infixOrder();	//1,2,3,5,7,9,10,12
	}

}

//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
	
	//查找要删除的节点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午8:43:01
	  * @param value 希望删除的结点的值
	  * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value){
		if(value == this.value){	//说明找到了
			return this;
		}else if(value < this.value){	//查找的值小于当前结点的值,向左子树查找
			if(this.left == null){	//左子结点为空
				return null;
			}
			return this.left.search(value);
		}else{	//查找的值不小于当前结点的值,向右子树查找
			if(this.right == null){
				return null;
			}
			return this.right.search(value);
		}
	}
	

	//查找要删除结点的父结点
	/**
	 * 
	 * @param value 希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value){
		//如果当前结点是要删除的结点的父结点,如果没有就返回null
		if((this.left != null && this.left.value == value)||
				(this.right != null && this.right.value == value)){
			return this;
		}else{
			//如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if(value < this.value && this.left != null){
				return this.left.searchP(value);	//向左子树查找
			}else if(value >= this.value && this.right != null){
				return this.right.searchP(value);	//向右子树递归查找
			}else {
				return null;	//未找到父结点
			}
		}
	}
	
	
}

//创建二叉排序树
class BinaryTree{
	private Node root;
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
	//查找要刪除的结点
	public Node search(int value){
		if(root == null){
			return null;
		}else{
			return root.search(value);
		}
	}
	//查找要删除的节点的父节点
	public Node searchP(int value){
		if(root == null){
			return null;
		}else{
			return root.searchP(value);
		}
	}
	
	//删除节点
	public void delNode(int value){
		if(root == null){
			return;
		}else{
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode == null){
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}
			//去找到targetNode的父结点
			Node parent = searchP(value);
			//如果要删除的节点为叶子节点
			if(targetNode.left == null && targetNode.right == null){
				//判断targetNode是父节点的左子结点,还是右子节点
				if(parent.left != null && parent.left.value == value){	//左子节点
					parent.left = null;
				}else if(parent.right != null && parent.right.value == value){	//右子节点
					parent.right = null;
				}
			}else if(targetNode.left != null && targetNode.right != null){	//删除有两颗子树的节点
				int maxVa = delRightT(targetNode.right);
				targetNode.value = maxVa;
			}else{	//删除只有一个字树的节点
				//如果要删除的结点有左子结点 
				if(targetNode.left != null) {
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.left;
						} else {	//targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						} 
					} else {
						root = targetNode.left;
					}
				}else{	//如果要删除的结点有右子结点 
					if(parent != null){
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value){
							parent.left = targetNode.right;
						}else{	//如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					}else{
						root = targetNode.right;
					}
				}
			}
		}
	}
	
	//编写方法
	//1.返回的 以node 为根结点的二叉排序树的最小结点的值
	//2.删除node 为根结点的二叉排序树的最小结点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午10:44:31
	  * @param node 传入的结点(为二叉排序树的根结点)
	  * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node){
		Node tar = node;
		//循环的查找左子节点，就会找到最大值
		while(tar.right != null){
			tar = tar.right;
		}
		//这时 target就指向了最大结点
		//删除最大结点
		delNode(tar.value);
//		System.out.println("子树最大:" + tar.value);
		return tar.value;
	}
}

平衡二叉树(AVL树)

平衡二叉树(AVL树)介绍

看一个案例(说明二叉排序树可能的问题)

• 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在。

左边BST 存在的问题分析:

• 左子树全部为空，从形式上看，更像一个单链表.

• 插入速度没有影响

• 查询速度明显降低(因为需要依次比较), 不能发挥BST
  的优势，因为每次还需要比较左子树，其查询速度比
  单链表还慢

• 解决方案——》平衡二叉树(AVL)

基本介绍

• 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。
• 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
• 举例说明, 看看下面哪些AVL树, 为什么?

AVL树左旋转思路图解

应用案例-单旋转(左旋转)

1.要求: 给你一个数列，创建出对应的平衡二叉树.数列 {4,3,6,5,7,8}

2.思路分析(示意图)

问题：当插入8 时

rightHeight() - leftHeight() > 1 成立，此时，不再是一颗avl树了.

怎么处理才能保证为AVL树 --> 进行左旋转.

具体步骤图解:

1.创建一个新的节点 newNode (以4这个值创建),创建一个新的节点，值等于当前根节点的值.

//把新节点的左子树设置了当前节点的左子树

2. newNode.left = left 
//把新节点的右子树设置为当前节点的右子树的左子树

3. newNode.right =right.left;
//把当前节点的值换为右子节点的值

4.value=right.value; 
//把当前节点的右子树设置成右子树的右子树

5. right=right.right;
//把当前节点的左子树设置为新节点

6. left=newLeft;

源自网络的动图:

AVL树高度求解

public class AVLTreeTest {

	public static void main(String[] args) {
		int[] arr = {4,3,6,5,7,8};  
		//创建一个 AVLTree对象
		AVLTree avlTree = new AVLTree();
		
		//添加结点
		for(int i=0; i < arr.length; i++) {
			avlTree.add(new Node(arr[i]));
		}
		
		//中序遍历
		System.out.println("中序遍历:");
		avlTree.infixOrder();	//3,4,5,6,7,8
		
		System.out.println("未经过平衡处理的树:");
		System.out.println("树的高度:" + avlTree.getRoot().height());	//4
		System.out.println("树的左子树高度:" + avlTree.getRoot().leftHeight()); // 1
		System.out.println("树的右子树高度:" + avlTree.getRoot().rightHeight()); // 3
		
	}

}
//创建Node结点
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	@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){	//如果当前结点左子结点为null
				this.left = node;
			}else{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else{	//添加的节点的值大于当前结点的值
			if(this.right == null){
				this.right = node;
			}else{
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if(this.left != null){
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null){
			this.right.infixOrder();
		}
	}
	
	//查找要删除的节点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午8:43:01
	  * @param value 希望删除的结点的值
	  * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value){
		if(value == this.value){	//说明找到了
			return this;
		}else if(value < this.value){	//查找的值小于当前结点的值,向左子树查找
			if(this.left == null){	//左子结点为空
				return null;
			}
			return this.left.search(value);
		}else{	//查找的值不小于当前结点的值,向右子树查找
			if(this.right == null){
				return null;
			}
			return this.right.search(value);
		}
	}
	

	//查找要删除结点的父结点
	/**
	 * 
	 * @param value 希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value){
		//如果当前结点是要删除的结点的父结点,如果没有就返回null
		if((this.left != null && this.left.value == value)||
				(this.right != null && this.right.value == value)){
			return this;
		}else{
			//如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if(value < this.value && this.left != null){
				return this.left.searchP(value);	//向左子树查找
			}else if(value >= this.value && this.right != null){
				return this.right.searchP(value);	//向右子树递归查找
			}else {
				return null;	//未找到父结点
			}
		}
	}
	
	//返回以该结点为根结点的树的高度
	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();
	}
	
}

//创建AVL树
class AVLTree{
	private Node root;
	
	public Node getRoot() {
		return root;
	}
	
	//添加结点的方法
	public void add(Node node){
		if(root == null){
			root = node;	//如果root为空则直接让root指向node
		}else{
			root.add(node);
		}
	}
	//遍历方法
	public void infixOrder(){
		if(root != null){
			root.infixOrder();
		}else{
			System.out.println("二叉排序树为空！！！");
		}
	}
	//查找要刪除的结点
	public Node search(int value){
		if(root == null){
			return null;
		}else{
			return root.search(value);
		}
	}
	//查找要删除的节点的父节点
	public Node searchP(int value){
		if(root == null){
			return null;
		}else{
			return root.searchP(value);
		}
	}
	
	//删除节点
	public void delNode(int value){
		if(root == null){
			return;
		}else{
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode ==null){
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}
			//去找到targetNode的父结点
			Node parent = searchP(value);
			//如果要删除的节点为叶子节点
			if(targetNode.left == null && targetNode.right == null){
				//判断targetNode是父节点的左子结点,还是右子节点
				if(parent.left != null && parent.left.value == value){	//左子节点
					parent.left = null;
				}else if(parent.right != null && parent.right.value == value){	//右子节点
					parent.right = null;
				}
			}else if(targetNode.left != null && targetNode.right != null){	//删除有两颗子树的节点
				int minVa = delRightT(targetNode.right);
				targetNode.value = minVa;
			}else{	//删除只有一个字树的节点
				//如果要删除的结点有左子结点 
				if(targetNode.left != null) {
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.left;
						} else {	//targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						} 
					} else {
						root = targetNode.left;
					}
				}else{	//如果要删除的结点有右子结点 
					if(parent != null){
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value){
							parent.left = targetNode.right;
						}else{	//如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					}else{
						root = targetNode.right;
					}
				}
			}
		}
	}
	
	//编写方法
	//1.返回的 以node 为根结点的二叉排序树的最小结点的值
	//2.删除node 为根结点的二叉排序树的最小结点
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月13日上午10:44:31
	  * @param node 传入的结点(为二叉排序树的根结点)
	  * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node){
		Node tar = node;
		//循环的查找左子节点，就会找到最小值
		while(tar.left != null){
			tar = tar.left;
		}
		//这时 target就指向了最小结点
		//删除最小结点
		delNode(tar.value);
		return tar.value;
	}
}

AVL树左旋转代码实现

public class AVLTreeTest {

	public static void main(String[] args) {
		int[] arr = { 4, 3, 6, 5, 7, 8 };
		// 创建一个 AVLTree对象
		AVLTree avlTree = new AVLTree();

		// 添加结点
		for (int i = 0; i < arr.length; i++) {
			avlTree.add(new Node(arr[i]));
		}

		// 中序遍历
		System.out.println("中序遍历:");
		avlTree.infixOrder(); // 3,4,5,6,7,8

		System.out.println("经过平衡处理的树:");
		System.out.println("树的高度:" + avlTree.getRoot().height()); // 3
		System.out.println("树的左子树高度:" + avlTree.getRoot().leftHeight()); // 2
		System.out.println("树的右子树高度:" + avlTree.getRoot().rightHeight()); // 2
		
	}

}

// 创建Node结点
class Node {
	int value;
	Node left;
	Node right;

	public Node(int value) {
		super();
		this.value = value;
	}

	@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) { // 如果当前结点左子结点为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) {
			leftRate();//左旋转
		}
		
	}

	// 中序遍历
	public void infixOrder() {
		if (this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.infixOrder();
		}
	}

	// 查找要删除的节点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午8:43:01
	 * @param value
	 *            希望删除的结点的值
	 * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value) {
		if (value == this.value) { // 说明找到了
			return this;
		} else if (value < this.value) { // 查找的值小于当前结点的值,向左子树查找
			if (this.left == null) { // 左子结点为空
				return null;
			}
			return this.left.search(value);
		} else { // 查找的值不小于当前结点的值,向右子树查找
			if (this.right == null) {
				return null;
			}
			return this.right.search(value);
		}
	}

	// 查找要删除结点的父结点
	/**
	 * 
	 * @param value
	 *            希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value) {
		// 如果当前结点是要删除的结点的父结点,如果没有就返回null
		if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
			return this;
		} else {
			// 如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if (value < this.value && this.left != null) {
				return this.left.searchP(value); // 向左子树查找
			} else if (value >= this.value && this.right != null) {
				return this.right.searchP(value); // 向右子树递归查找
			} else {
				return null; // 未找到父结点
			}
		}
	}

	// 返回以该结点为根结点的树的高度
	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 leftRate() {
		// 创建新的结点，以当前根结点的值
		Node newNode = new Node(value);
		// 把新的结点的左子树设置成当前结点的左子树
		newNode.left = left;
		// 把新的结点的右子树设置成带你过去结点的右子树的左子树
		newNode.right = right.left;
		// 把当前结点的值替换成右子结点的值
		value = right.value;
		// 把当前结点的右子树设置成当前结点右子树的右子树
		right = right.right;
		// 把当前结点的左子树(左子结点)设置成新的结点
		left = newNode;
	}

}

// 创建AVL树
class AVLTree {
	private Node root;

	public Node getRoot() {
		return root;
	}

	// 添加结点的方法
	public void add(Node node) {
		if (root == null) {
			root = node; // 如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}

	// 遍历方法
	public void infixOrder() {
		if (root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空！！！");
		}
	}

	// 查找要刪除的结点
	public Node search(int value) {
		if (root == null) {
			return null;
		} else {
			return root.search(value);
		}
	}

	// 查找要删除的节点的父节点
	public Node searchP(int value) {
		if (root == null) {
			return null;
		} else {
			return root.searchP(value);
		}
	}

	// 删除节点
	public void delNode(int value) {
		if (root == null) {
			return;
		} else {
			// 1.需求先去找到要删除的结点 targetNode
			Node targetNode = search(value);
			// 如果没有找到要删除的结点
			if (targetNode == null) {
				return;
			}
			// 如果我们发现当前这颗二叉排序树只有一个结点
			if (root.left == null && root.right == null) {
				root = null;
				return;
			}
			// 去找到targetNode的父结点
			Node parent = searchP(value);
			// 如果要删除的节点为叶子节点
			if (targetNode.left == null && targetNode.right == null) {
				// 判断targetNode是父节点的左子结点,还是右子节点
				if (parent.left != null && parent.left.value == value) { // 左子节点
					parent.left = null;
				} else if (parent.right != null && parent.right.value == value) { // 右子节点
					parent.right = null;
				}
			} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点
				int minVa = delRightT(targetNode.right);
				targetNode.value = minVa;
			} else { // 删除只有一个字树的节点
				// 如果要删除的结点有左子结点
				if (targetNode.left != null) {
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.left;
						} else { // targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}
				} else { // 如果要删除的结点有右子结点
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.right;
						} else { // 如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}
			}
		}
	}

	// 编写方法
	// 1.返回的 以node 为根结点的二叉排序树的最小结点的值
	// 2.删除node 为根结点的二叉排序树的最小结点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午10:44:31
	 * @param node
	 *            传入的结点(为二叉排序树的根结点)
	 * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node) {
		Node tar = node;
		// 循环的查找左子节点，就会找到最小值
		while (tar.left != null) {
			tar = tar.left;
		}
		// 这时 target就指向了最小结点
		// 删除最小结点
		delNode(tar.value);
		return tar.value;
	}
}

上面的左旋转，仅仅是左旋转，考虑并不完全，完整的旋转代码，参考下方的双旋转！！！

AVL树右旋转图解和实现

应用案例-单旋转(右旋转)

1.要求: 给你一个数列，创建出对应的平衡二叉树.数列 {10,12, 8, 9, 7, 6}

2.思路分析(示意图)

问题：当插入6 时
leftHeight()  - rightHeight()  > 1 成立，此时，不再是一颗avl树了.

怎么处理 --> 进行右旋转.[就是降低左子树的高度], 这里是将9 这个节点，通过右旋转，到右子树

1. 创建一个新的节点 newNode (以10这个值创建),创建一个新的节点，值等于当前根节点的值

//把新节点的右子树设置了当前节点的右子树

2. newNode.right = right 
//把新节点的左子树设置为当前节点的左子树的右子树

3. newNode.left =left.right;
//把当前节点的值换为左子节点的值

4.value=left.value; 
//把当前节点的左子树设置成左子树的左子树

5. left=left.left;
//把当前节点的右子树设置为新节点

6. right=newLeft;

源自网络的动图:

代码实现如下：

public class AVLTreeTest {

	public static void main(String[] args) {
//		int[] arr = { 4, 3, 6, 5, 7, 8 };
		int arr[] = { 10,12, 8, 9, 7, 6};
		// 创建一个 AVLTree对象
		AVLTree avlTree = new AVLTree();

		// 添加结点
		for (int i = 0; i < arr.length; i++) {
			avlTree.add(new Node(arr[i]));
		}

		// 中序遍历
		System.out.println("中序遍历:");
		avlTree.infixOrder(); // 3,4,5,6,7,8

		System.out.println("经过平衡处理的树:");
		System.out.println("树的高度:" + avlTree.getRoot().height()); // 3
		System.out.println("树的左子树高度:" + avlTree.getRoot().leftHeight()); // 2
		System.out.println("树的右子树高度:" + avlTree.getRoot().rightHeight()); // 2
		System.out.println("当前的根节点:" + avlTree.getRoot());
	}

}

// 创建Node结点
class Node {
	int value;
	Node left;
	Node right;

	public Node(int value) {
		super();
		this.value = value;
	}

	@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) { // 如果当前结点左子结点为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) {
			leftRate(); //左旋转
		}
		
		//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
		if(leftHeight() - rightHeight() > 1) {
			rightRotate(); //右旋转
		}
		
	}

	// 中序遍历
	public void infixOrder() {
		if (this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.infixOrder();
		}
	}

	// 查找要删除的节点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午8:43:01
	 * @param value
	 *            希望删除的结点的值
	 * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value) {
		if (value == this.value) { // 说明找到了
			return this;
		} else if (value < this.value) { // 查找的值小于当前结点的值,向左子树查找
			if (this.left == null) { // 左子结点为空
				return null;
			}
			return this.left.search(value);
		} else { // 查找的值不小于当前结点的值,向右子树查找
			if (this.right == null) {
				return null;
			}
			return this.right.search(value);
		}
	}

	// 查找要删除结点的父结点
	/**
	 * 
	 * @param value
	 *            希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value) {
		// 如果当前结点是要删除的结点的父结点,如果没有就返回null
		if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
			return this;
		} else {
			// 如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if (value < this.value && this.left != null) {
				return this.left.searchP(value); // 向左子树查找
			} else if (value >= this.value && this.right != null) {
				return this.right.searchP(value); // 向右子树递归查找
			} else {
				return null; // 未找到父结点
			}
		}
	}

	// 返回以该结点为根结点的树的高度
	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 leftRate() {
		// 创建新的结点，以当前根结点的值
		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;
	}
	
}

// 创建AVL树
class AVLTree {
	private Node root;

	public Node getRoot() {
		return root;
	}

	// 添加结点的方法
	public void add(Node node) {
		if (root == null) {
			root = node; // 如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}

	// 遍历方法
	public void infixOrder() {
		if (root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空！！！");
		}
	}

	// 查找要刪除的结点
	public Node search(int value) {
		if (root == null) {
			return null;
		} else {
			return root.search(value);
		}
	}

	// 查找要删除的节点的父节点
	public Node searchP(int value) {
		if (root == null) {
			return null;
		} else {
			return root.searchP(value);
		}
	}

	// 删除节点
	public void delNode(int value) {
		if (root == null) {
			return;
		} else {
			// 1.需求先去找到要删除的结点 targetNode
			Node targetNode = search(value);
			// 如果没有找到要删除的结点
			if (targetNode == null) {
				return;
			}
			// 如果我们发现当前这颗二叉排序树只有一个结点
			if (root.left == null && root.right == null) {
				root = null;
				return;
			}
			// 去找到targetNode的父结点
			Node parent = searchP(value);
			// 如果要删除的节点为叶子节点
			if (targetNode.left == null && targetNode.right == null) {
				// 判断targetNode是父节点的左子结点,还是右子节点
				if (parent.left != null && parent.left.value == value) { // 左子节点
					parent.left = null;
				} else if (parent.right != null && parent.right.value == value) { // 右子节点
					parent.right = null;
				}
			} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点
				int minVa = delRightT(targetNode.right);
				targetNode.value = minVa;
			} else { // 删除只有一个字树的节点
				// 如果要删除的结点有左子结点
				if (targetNode.left != null) {
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.left;
						} else { // targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}
				} else { // 如果要删除的结点有右子结点
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.right;
						} else { // 如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}
			}
		}
	}

	// 编写方法
	// 1.返回的 以node 为根结点的二叉排序树的最小结点的值
	// 2.删除node 为根结点的二叉排序树的最小结点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午10:44:31
	 * @param node
	 *            传入的结点(为二叉排序树的根结点)
	 * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node) {
		Node tar = node;
		// 循环的查找左子节点，就会找到最小值
		while (tar.left != null) {
			tar = tar.left;
		}
		// 这时 target就指向了最小结点
		// 删除最小结点
		delNode(tar.value);
		return tar.value;
	}
}

上面的右旋转，仅仅是右旋转，考虑并不完全，完整的旋转代码，参考下方的双旋转！！！

AVL树双旋转图解和实现

应用案例-双旋转

前面的两个数列，进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但是在某些情况下，单旋转不能完成平衡二叉树的转换。比如数列

int[] arr = { 10, 11, 7, 6, 8, 9 }; 运行原来的代码可以看到，并没有转成AVL树.

int[]arr= {2,1,6,5,7,3}; // 运行原来的代码可以看到，并没有转成 AVL树

问题分析:  
在满足右旋转条件时，要判断:
(1)如果 是 左子树的 右子树高度 大于左子树的左子树时：
(2)就是 对  当前根节点的左子树，先进行 左旋转，
(3)然后， 再对当前根节点进行右旋转即可

否则，直接对当前节点（根节点）进行右旋转.即可.

1. 先对当前节点的左子树，进行左旋转

2. 再对当前节点，进行右旋转

具体代码分析:

public class AVLTreeTest {

	public static void main(String[] args) {
//		int[] arr = { 4, 3, 6, 5, 7, 8 };
		int arr[] = { 10,12, 8, 9, 7, 6};
		// 创建一个 AVLTree对象
		AVLTree avlTree = new AVLTree();

		// 添加结点
		for (int i = 0; i < arr.length; i++) {
			avlTree.add(new Node(arr[i]));
		}

		// 中序遍历
		System.out.println("中序遍历:");
		avlTree.infixOrder(); // 3,4,5,6,7,8

		System.out.println("经过平衡处理的树:");
		System.out.println("树的高度:" + avlTree.getRoot().height()); // 3
		System.out.println("树的左子树高度:" + avlTree.getRoot().leftHeight()); // 2
		System.out.println("树的右子树高度:" + avlTree.getRoot().rightHeight()); // 2
		System.out.println("当前的根节点:" + avlTree.getRoot());
	}

}

// 创建Node结点
class Node {
	int value;
	Node left;
	Node right;

	public Node(int value) {
		super();
		this.value = value;
	}

	@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) { // 如果当前结点左子结点为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()) {
				//先对右子结点进行右旋转
				right.rightRotate();
				//然后在对当前结点进行左旋转
				leftRate(); //左旋转
			} else {
				//直接进行左旋转即可
				leftRate();
			}
			return; //重要!!!
		}
		
		//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
		if(leftHeight() - rightHeight() > 1) {
			//如果它的左子树的右子树高度大于它的左子树的高度
			if(left != null && left.rightHeight() > left.leftHeight()){
				//先对当前结点的左结点(左子树)->左旋转
				left.leftRate();
				//再对当前结点进行右旋转
				rightRotate();
			}else{
				//直接进行右旋转即可
				rightRotate();
			}
		}
		
	}

	// 中序遍历
	public void infixOrder() {
		if (this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if (this.right != null) {
			this.right.infixOrder();
		}
	}

	// 查找要删除的节点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午8:43:01
	 * @param value
	 *            希望删除的结点的值
	 * @return 如果找到该值返回,未找到返回null
	 */
	public Node search(int value) {
		if (value == this.value) { // 说明找到了
			return this;
		} else if (value < this.value) { // 查找的值小于当前结点的值,向左子树查找
			if (this.left == null) { // 左子结点为空
				return null;
			}
			return this.left.search(value);
		} else { // 查找的值不小于当前结点的值,向右子树查找
			if (this.right == null) {
				return null;
			}
			return this.right.search(value);
		}
	}

	// 查找要删除结点的父结点
	/**
	 * 
	 * @param value
	 *            希望删除的结点的值
	 * @return 返回的是要删除的结点的父结点,如果没有就返回null
	 */
	public Node searchP(int value) {
		// 如果当前结点是要删除的结点的父结点,如果没有就返回null
		if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
			return this;
		} else {
			// 如果查找的值小于当前结点的值,且当前结点的左子结点不为空
			if (value < this.value && this.left != null) {
				return this.left.searchP(value); // 向左子树查找
			} else if (value >= this.value && this.right != null) {
				return this.right.searchP(value); // 向右子树递归查找
			} else {
				return null; // 未找到父结点
			}
		}
	}

	// 返回以该结点为根结点的树的高度
	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 leftRate() {
		// 创建新的结点，以当前根结点的值
		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;
	}
	
}

// 创建AVL树
class AVLTree {
	private Node root;

	public Node getRoot() {
		return root;
	}

	// 添加结点的方法
	public void add(Node node) {
		if (root == null) {
			root = node; // 如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}

	// 遍历方法
	public void infixOrder() {
		if (root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空！！！");
		}
	}

	// 查找要刪除的结点
	public Node search(int value) {
		if (root == null) {
			return null;
		} else {
			return root.search(value);
		}
	}

	// 查找要删除的节点的父节点
	public Node searchP(int value) {
		if (root == null) {
			return null;
		} else {
			return root.searchP(value);
		}
	}

	// 删除节点
	public void delNode(int value) {
		if (root == null) {
			return;
		} else {
			// 1.需求先去找到要删除的结点 targetNode
			Node targetNode = search(value);
			// 如果没有找到要删除的结点
			if (targetNode == null) {
				return;
			}
			// 如果我们发现当前这颗二叉排序树只有一个结点
			if (root.left == null && root.right == null) {
				root = null;
				return;
			}
			// 去找到targetNode的父结点
			Node parent = searchP(value);
			// 如果要删除的节点为叶子节点
			if (targetNode.left == null && targetNode.right == null) {
				// 判断targetNode是父节点的左子结点,还是右子节点
				if (parent.left != null && parent.left.value == value) { // 左子节点
					parent.left = null;
				} else if (parent.right != null && parent.right.value == value) { // 右子节点
					parent.right = null;
				}
			} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点
				int minVa = delRightT(targetNode.right);
				targetNode.value = minVa;
			} else { // 删除只有一个字树的节点
				// 如果要删除的结点有左子结点
				if (targetNode.left != null) {
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.left;
						} else { // targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}
				} else { // 如果要删除的结点有右子结点
					if (parent != null) {
						// 如果 targetNode 是 parent 的左子结点
						if (parent.left.value == value) {
							parent.left = targetNode.right;
						} else { // 如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}
			}
		}
	}

	// 编写方法
	// 1.返回的 以node 为根结点的二叉排序树的最小结点的值
	// 2.删除node 为根结点的二叉排序树的最小结点
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月13日上午10:44:31
	 * @param node
	 *            传入的结点(为二叉排序树的根结点)
	 * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightT(Node node) {
		Node tar = node;
		// 循环的查找左子节点，就会找到最小值
		while (tar.left != null) {
			tar = tar.left;
		}
		// 这时 target就指向了最小结点
		// 删除最小结点
		delNode(tar.value);
		return tar.value;
	}
}

本章思维导图