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

电玩女神 2023-02-17 11:23 16阅读 0赞

### 文章目录 ###

*  第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)，要求能够高效的完成对数据的查询和添加。

> **解决方案分析**：

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]

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

> **二叉排序树介绍**：

*  二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
 *  **特别说明**：如果有相同的值，可以将该节点放在左子节点或右子节点
 *  比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]

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

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

![在这里插入图片描述][20200613211221615.png_pic_center]

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

> 二叉排序树的删除情况比较复杂，有下面三种情况需要考虑
> 
> 1)删除叶子节点 (比如：2, 5, 9, 12)
> 
> 2)删除只有一颗子树的节点 (比如：1)
> 
> 3)删除有两颗子树的节点. (比如：7, 3，10 )

![在这里插入图片描述][2020061321124324.png_pic_center]

### 二叉排序树删除叶子结点 ###

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

第一种情况: 删除叶子节点 (比如：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), 并分析问题所在。

![在这里插入图片描述][20200613211322982.png_pic_center]

> **左边BST** **存在的问题分析**:

*  左子树全部为空，从形式上看，更像一个单链表.
 *  插入速度没有影响
 *  查询速度明显降低(因为需要依次比较), 不能发挥BST  
    的优势，因为每次还需要比较左子树，其查询速度比  
    单链表还慢
 *  解决方案——》平衡二叉树(AVL)

> **基本介绍**

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]

### AVL树左旋转思路图解 ###

> **应用案例-单旋转(左旋转)**
> 
> 1.要求: 给你一个数列，创建出对应的平衡二叉树.数列 \{4,3,6,5,7,8\}
> 
> 2.思路分析(示意图)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]

> 问题：当插入8 时
> 
> rightHeight() - leftHeight() > 1 成立，此时，不再是一颗avl树了.
> 
> 怎么处理才能保证为AVL树 --> 进行**左旋转**.

具体步骤图解:
    
    1.创建一个新的节点 newNode (以4这个值创建),创建一个新的节点，值等于当前根节点的值.
    
    //把新节点的左子树设置了当前节点的左子树

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 8]

6. left=newLeft;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 9]

> 源自网络的动图:

![在这里插入图片描述][20200613211456388.gif_pic_center]

### 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 这个节点，通过右旋转，到右子树

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 10]

1. 创建一个新的节点 newNode (以10这个值创建),创建一个新的节点，值等于当前根节点的值
    
    //把新节点的右子树设置了当前节点的右子树

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 11]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 12]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 13]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 14]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 15]

6. right=newLeft;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 16]

> 源自网络的动图:

![在这里插入图片描述][20200613211638896.gif_pic_center]

> 代码实现如下：

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树**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 17]

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 18]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 19]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 21]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 24]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 25]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 26]

> 具体代码分析:

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

## 本章思维导图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 27]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200613211201449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2020061321121294.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[20200613211221615.png_pic_center]: https://img-blog.csdnimg.cn/20200613211221615.png#pic_center
[2020061321124324.png_pic_center]: https://img-blog.csdnimg.cn/2020061321124324.png#pic_center
[20200613211322982.png_pic_center]: https://img-blog.csdnimg.cn/20200613211322982.png#pic_center
[Link 1]: https://baike.baidu.com/item/%E7%BA%A2%E9%BB%91%E6%A0%91/2413209
[AVL]: https://baike.baidu.com/item/AVL/7543015
[Link 2]: https://baike.baidu.com/item/%E6%9B%BF%E7%BD%AA%E7%BE%8A%E6%A0%91/13859070
[Treap]: https://baike.baidu.com/item/Treap
[Link 3]: https://baike.baidu.com/item/%E4%BC%B8%E5%B1%95%E6%A0%91/7003945
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200613211339269.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200613211347914.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200613211357606.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200613211406728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20200613211417727.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20200613211427590.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20200613211436850.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20200613211446421.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[20200613211456388.gif_pic_center]: https://img-blog.csdnimg.cn/20200613211456388.gif#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20200613211522488.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20200613211533388.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/2020061321154475.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20200613211559140.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20200613211609715.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 15]: https://img-blog.csdnimg.cn/20200613211619820.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 16]: https://img-blog.csdnimg.cn/20200613211628934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[20200613211638896.gif_pic_center]: https://img-blog.csdnimg.cn/20200613211638896.gif#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 17]: https://img-blog.csdnimg.cn/20200613211659445.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 18]: https://img-blog.csdnimg.cn/20200613211712751.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 19]: https://img-blog.csdnimg.cn/20200613211722137.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 20]: https://img-blog.csdnimg.cn/20200613211732291.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 21]: https://img-blog.csdnimg.cn/20200613211740205.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 22]: https://img-blog.csdnimg.cn/20200613211748469.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 23]: https://img-blog.csdnimg.cn/20200613211756672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 24]: https://img-blog.csdnimg.cn/20200613211807404.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 25]: https://img-blog.csdnimg.cn/20200613211817842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 26]: https://img-blog.csdnimg.cn/20200613211827153.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 27]: https://img-blog.csdnimg.cn/20200613211902661.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center