数据结构（十）---二叉排序树
基本介绍
1）使用数组
1-数组未排序
优点：直接在数组最后添加，速度快
缺点：查找需要遍历，速度慢
2-数组排序
优点：可以使用二分查找，查找的速度很快
缺点：为了保证数组有序，在添加新数据时，找到插入位置，后面的数据需要整体移动，导致添加的速度很慢
2）使用链表存储
不管链表是否有序，查找的速度都很慢，因为没有索引，只能通过遍历的方式挨个查找
但是添加的速度很快，不需要移动整体数据
3）使用二叉排序树
问题1-什么是二叉排序树
问题2-二叉排序树可以使插入和查找的速度都很快，为什么使用树结构就能很快？
回答1：
二叉排序树要求，任何一个非叶子节点，要求左子节点的值都比当前节点的值要小，右子节点的值都比当前节点的值大
如果有相同的值，可以把这个节点放在左子节点或者右子节点
所以插入一个值的时候，从根节点开始比较，小就往左子树去，大就往右子树去，
（2）二叉排序树删除节点
1）删除叶子结点
思路：
1-需求先去找到要删除的节点targetNode
2-找到targetNode的父节点parent（考虑是否存在父节点）
3-确定targetNode是父节点parent的左子节点，还是右子节点
4-根据前面的情况来对应删除
2）删除只有一棵子树的节点
思路：
1-需求先去找到要删除的节点
2-找到目标节点的父节点
3-确定目标节点的子节点是左子节点还是右子节点
4-目标节点是父节点的左子节点还是右子节点
5-如果目标节点是父节点的左子节点
（删除类似于链表的删除，把子节点接在父节点的后面就行了）
3）删除有两棵树的节点
思路：
1-需求先去找到要删除的节点
2-找到目标节点的父节点
3-从目标节点的右子树找到最小的节点
4-用一个临时变量，把最小节点的值保存到temp
5-删除该最小节点
6-把这个临时变量的值赋给目标节点
创建节点类
//创建Node节点
class Node{
int value;
//这两个左右子节点就是创建节点包含的内容，可以调用
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
//查找要删除的节点
/**给出目标节点的值value，如果能找到就返回这个Node
* @MethodName: search
* @Author: AllenSun
* @Date: 2019/11/12 21:51
*/
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);
}
}
//查找要删除节点的父节点
/**value是要删除节点的值
* Node是找到后要返回的父节点，没找到就返回null
* @MethodName: searchParent
* @Author: AllenSun
* @Date: 2019/11/12 21:35
*/
public Node searchParent(int value){
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.searchParent(value);//向左子树递归查找
} else if(value>=this.value && this.right!=null){
//如果大，并且右子节点不为空，那就向右子树递归查找
return this.right.searchParent(value);//向右子树递归查找
} else {
return null;//没有找到
}
}
}
//递归的形式添加节点，注意需要满足二叉排序树的要求
/**添加节点的方法
* @MethodName: add
* @Author: AllenSun
* @Date: 2019/11/12 21:52
*/
public void add(Node node){
//先判断添加的节点是不是空的
if(node==null){
return;
}
//判断传入的节点的值，和当前子树的根节点的值关系，如果小的话就往左子树去，如果大的话就往右子树去
if(node.value<this.value){
//如果当前节点左子节点为null，那就可以直接赋值
if(this.left==null){
this.left=node;
} else {
//如果不是空的，那就得递归，继续跟左子树比较，然后添加
this.left.add(node);
}
} else {
//如果当前节点右子节点为null，那就可以直接赋值
if(this.right==null){
this.right=node;
} else {
//如果不是空的，那就得递归，继续跟右子树比较，然后添加
this.right.add(node);
}
}
}
/**中序遍历
* @MethodName: infixOrder
* @Author: AllenSun
* @Date: 2019/11/12 21:51
*/
public void infixOrder(){
//如果左子节点不是空的，那就递归继续往左遍历
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);
if(this.right!=null){
this.right.infixOrder();
}
}
}
用节点创建二叉排序树
//用节点创建二叉排序树
class BinarySortTree{
private Node root;
//查找要删除的节点，把删除节点的两个方法封装在一起
public Node search(int value){
if(root ==null){
return null;
} else {
//不为空，那就可以查找
return root.search(value);
}
}
//再封装查找父节点的方法
public Node searchParent(int value){
if(root==null){
return null;
}else {
return root.searchParent(value);
}
}
//写一个找子树中最小节点的方法（当删除节点有两个子节点时，要找最小节点值）
//传入一个节点node，当做是二叉排序树的根节点
//返回的是以node为根节点的二叉排序树的最小节点的值
public int delRightTreeMin(Node node){
Node target=node;
//循环的查找左节点，就会找到最小值
while(target.left!=null){
target=target.left;
}
//这时target就指向了最小节点
//删除最小节点
delNode(target.value);
return target.value;
}
//删除节点
public void delNode(int value){
if(root==null){
return;
} else {
//1-先找到要删除的节点
Node targetNode=search(value);
//如果没有找到要删除的节点
if(targetNode==null){
return;
}
//如果我们发现targetNode没有父节点，比如删除的就是根节点，或者说当前二叉排序树只有一个节点
if(root.left==null && root.right==null){
//只有一个节点，并且就是我们要找的节点，直接删除就行了，删除也就是置为空
root=null;
}
//2-去找到targetNode的父节点
Node parent=searchParent(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;
}
// targetNode=null;//不能直接这样置为空，这样只是空节点，并没有删除节点
} else if(targetNode.left!=null && targetNode.right!=null){
//就说明targetNode有两个子树
//调用写的delRightTreeMin方法，从右子树找最小的取代要删除的节点
int minVal=delRightTreeMin(targetNode.right);
targetNode.value=minVal;
} else {
//排除上面两种情况，剩下的自然就是targetNode只有一棵子树
//先判断targetNode的子节点是左子节点还是右子节点
//1-targetNode有左子节点
if(targetNode.left!=null){
//如果targetNode的父节点是空的，说明这个点就是根节点，它没有父节点
if(parent!=null){
//1-1-如果targetNode是parent的左子节点
if(parent.left.value==value){
parent.left=targetNode.left;//这样就把targetNode删除了
} else {
//1-2-targetNode是parent的右子节点
parent.right=targetNode.left;//这样就把targetNode删除了
}
} else {
root=targetNode.left;
}
}
//2-targetNode有右子节点
if(targetNode.right!=null){
if(parent!=null){
//2-1-如果targetNode是parent的左子节点
if(parent.left.value==value){
parent.left=targetNode.right;
} else {
//2-2-如果targetNode是parent的右子节点
parent.right=targetNode.right;
}
} else {
root=targetNode.right;
}
}
}
}
}
//添加节点的方法，root为空就直接放root位置，不为空就调用add方法往左右子节点放
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 class BinarySortTreeDemo {
public static void main(String[] args) {
int[] arr={7,3,10,12,5,1,9,0};
BinarySortTree binarySortTree = new BinarySortTree();
//循环的添加节点到二叉排序树
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new Node(arr[i]));
}
//中序遍历
System.out.println("中序遍历二叉排序树");
binarySortTree.infixOrder();
//测试一下删除拍序二叉树的叶子节点
binarySortTree.delNode(10);
System.out.println("删除节点以后");
binarySortTree.infixOrder();
}
}
