三十一、二叉排序树的创建、删除和遍历

一、实际需求

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

解决方案一：使用数组

数组未排序， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢.

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

解决方案二：使用链式存储-链表

不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。

解决方案三：使用二叉排序树

二、二叉排序树的介绍

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

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

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

三、二叉排序树的创建、结点删除和遍历

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

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

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

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

操作思路分析：

第一种情况：删除叶子结点

1. 需要找到要删除的结点 targetNode

2. 需要找到targetNode 的父节点

3. 需要确定targetNode是parent的左子节点还是右子节点

4. 根据前面的情况来进行删除

左子结点 parent.left = null 右子结点 parent.right = null;

第二种情况：删除只有一颗子树的结点，比如1

1. 需要找到要删除的结点 targetNode

2. 需要找到targetNode 的父节点

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

第三种情况：删除有两颗子树的结点

1. 需要找到要删除的结点 targetNode

2. 需要找到targetNode 的父节点

3. 从targetNode的右子树中找到最小的结点（或者找到其左子树的最大节点）

4. 用一个临时变量，将 最小结点的值保存 temp

5. 删除该最小结点

6. targetNode.value=temp

四、代码实现

package cn.zzw.algorithm.binarysorttree;

public class BinarySortTreeDemo {
    
    

    public static void main(String[] args) {
    
    

        int[] arr={
    
    7,3,10,12,5,1,9,2};
        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(2);

        //测试只有一颗子树的结点
        //binarySortTree.delNode(1);

        //测试有两颗子树的结点
        binarySortTree.delNode(7);

        //删除结点之后的中序遍历
        System.out.println("删除结点之后的中序遍历");
        binarySortTree.infixOrder();
    }

}

//创建二叉排序树
class BinarySortTree
{
    
    
    private Node root;

    //添加结点的方法
    public void add(Node node)
    {
    
    
        if(root==null)
        {
    
    
            //如果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 searchParent(int value)
    {
    
    
        if (root==null)
        {
    
    
            return null;
        }
        else
        {
    
    
            return root.searchParent(value);
        }
    }

    //1. 返回的以node 为根结点的二叉排序树的最小结点的值
    //2. 删除 node 为根结点的二叉排序树的最小结点
    public int delRightTreeMin(Node node)
    {
    
    
        Node target =node;
        //循环查找左子节点，就会找到最小值
        while (target.left!=null)
        {
    
    
            target=target.left;
        }
        //循环退出时就找到了最小值
        //找到最小值便删除它
        delNode(target.value);
        return target.value;
    }

    //删除结点
    public void delNode(int value)
    {
    
    
        if(root==null)
        {
    
    
            return;
        }
        else
        {
    
    
            //需要先去找到要删除的结点
            Node targetNode=search(value);
            //如果没有找到要删除的结点
            if (targetNode==null)
            {
    
    
                return;
            }
            //如果我们发现当前这颗二叉树只有一个结点
            if (root.left==null && root.right==null)
            {
    
    
                root=null;
                return;
            }

            //去找到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;
                }
            }
            //如果删除的是有两颗子树的结点
            else if (targetNode.left!=null && targetNode.right!=null)
            {
    
    
                int minVal=delRightTreeMin(targetNode.right);
                targetNode.value=minVal;
            }
            //删除只有一颗子树的结点
            else
            {
    
    
                //如果要删除的结点有左子节点
                if (targetNode.left!=null)
                {
    
    
                    //如果此时要删除的结点的父节点为不为空
                    if (parent!=null)
                    {
    
    
                        //如果targetNode是parent的左子节点
                        if (parent.left.value==value)
                        {
    
    
                            parent.left=targetNode.left;
                        }
                        //如果targetNode是parent的右子节点
                        else
                        {
    
    
                            parent.right=targetNode.left;
                        }
                    }
                    else
                    {
    
    
                        root=targetNode.left;
                    }
                }
                //如果要删除的结点有右子节点
                else
                {
    
    
                    if (parent!=null)
                    {
    
    
                        //如果要targetNode是parent的左子节点
                        if (parent.left.value==value)
                        {
    
    
                            parent.left=targetNode.right;
                        }
                        //如果targetNode是parent的右子节点
                        else
                        {
    
    
                            parent.right=targetNode.right;
                        }
                    }
                    else
                    {
    
    
                        root=root.right;
                    }
                }
            }
        }
    }
}


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

    public Node(int value)
    {
    
    
        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)
            {
    
    
                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();
        }
    }

    /**
     * 方法功能：希望找到待删除的结点
     * @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);
        }
    }

    //查找要删除结点的父节点
    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;
            }
        }
    }

}

测试结果：

"C:\Program Files\Java\jdk1.8.0_181\bin\java.exe" "-javaagent:D:\IntelliJ IDEA\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=16275:D:\IntelliJ IDEA\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;C:\Users\1\IdeaProjects\algorithm\out\production\algorithm" cn.zzw.algorithm.binarysorttree.BinarySortTreeDemo
中序遍历二叉树~
Node{
    
    value=1}
Node{
    
    value=2}
Node{
    
    value=3}
Node{
    
    value=5}
Node{
    
    value=7}
Node{
    
    value=9}
Node{
    
    value=10}
Node{
    
    value=12}
删除结点之后的中序遍历
Node{
    
    value=1}
Node{
    
    value=2}
Node{
    
    value=3}
Node{
    
    value=5}
Node{
    
    value=9}
Node{
    
    value=10}
Node{
    
    value=12}

Process finished with exit code 0