二叉搜索树

念君思宁
60 阅读5分钟

对于二叉搜索树，想必刚看见这个题目的时候，大部分读者能够想出最底层的实现是依靠于：二叉树来的吧！！其实对于二叉树，怎么来说呢？代码写起来没有多大的难度！但是，重在于思路！！因此，多练练，多想想其他的思路，那么，二叉树的难点便不再是难点！！对于二叉树笔者在之前写过几篇文章，感兴趣的可以去看一下！！

二叉树的详解：blog.csdn.net/weixin_6430…

二叉树的相关列题：blog.csdn.net/weixin_6430…

想必看过前面两篇文章的你，对于二叉树环节，已经能够得心应手了吧！！对于二叉树，还是需要多练习练习！！

言归正传！接下来笔者要讲述的就是二叉搜素树的正题了！！

二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有一下性质的二叉树！！

1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值！

2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值！！

3.它的左右子树也分别为二叉搜索树！！！

需要注意的是：二叉搜索树中，不能出现两个相同的节点！！（没有意义）

11ffbcd5ce47a118661c8faa8905cb44.png 对于上述的这种情况，就不是二叉搜索树！！但是，是一颗二叉树！！

有了上述的这个情况，那么，接下来我们就该研究研究如何实现二叉搜索树了！！

首先，在开始的情况下，我们需要先有一个静态内部类，里面定义二叉树的有关数据，如：存储的数据，左节点，右节点，那么，接下来请看笔者的代码吧！！

笔者定义了一个文件，名称为：BinarySearchTree.java 文件！

    static class TreeNode{
        //定义静态内部类
        public int val;
        public TreeNode left;
        public TreeNode right;
 
        //构造方法！
        public TreeNode(int val) {
            this.val = val;
        }
    }

接下来，我们就可以进行相关的操作了！！

定义一个根节点！

    //定义一个根节点
    public TreeNode root=null;

1.查找二叉搜索树中指定的val的值！并且返回所对应的地址！

在进行之前，我们还是需要注意一下：二叉搜索树的特点！！

07f70393b3ac9de32605665acb49465e.png 根据这个性质，我们在进行查找的时候，会发现效率比较高！！毕竟每次的查找都会之间pass一半的数据！！在及其特别的情况下是该二叉搜索树的高度！！

那么，有了上述的积累，我们就可以进行该代码的书写了！！

   public TreeNode find(int val){
        TreeNode cur=root;
        
        while (cur!=null){
            if (cur.val<val){
                cur=cur.right;//右边查找，左边的数据已经pass了！
            }else if (cur.val==val){
                return cur;
            }else {
                cur=cur.left;//左边查找，右边数据已经pass了！
            }
        }
        //循环走完了，左右两边的数据都没有找到！
        return null;
    }

整体的代码思路很简单！！但是，也得有着自己的解题思路！！ 2.插入一个数据！

对于插入数据来说，其实每次的插入的最后结果都会在叶子节点上！！其原因就是：二叉树的特殊结果！！

  //插入一个数据
    public void insert(int val){
        if (root==null){
            return;
        }
        
        TreeNode cur=root;
        TreeNode parent=null;
        
        while (cur !=null){
            if (cur.val<val){
                parent=cur;
                cur=cur.right;
            }else if (cur.val==val){
                return;
                //二叉搜素树中，不要有两个一样的数据，这样没意义！
            }else {
                parent=cur;
                cur=cur.left;
            }
        }
        
        //当出while循环的时候，此时cur==null
        //将要插入的数据进行实列化节点！
        TreeNode node=new TreeNode(val);
        //判断一下新的节点是插入在左边还是插入在右边！
        if (parent.val<val){
            parent.right=node;
        }else {
            parent.left=node;
        }
    }

对于该段代码中，我们用了一个cur ，parent 来进行遍历，虽然cur到最后为空了，但是， 我们通过parent来找到需要插入节点的位置（通过比较），最后插入了新的节点！！

最后，虽然我们可以通过调试来得到最后的二叉搜素树的树型！但是，通过中序遍历我们之间就能得到一个有序的数据（可以通过中序遍历来观察二叉搜索树是否正确！） 3.中序遍历打印二叉搜索树！

对于这个代码，想必在进行二叉树的环节的时候，各位已经熟悉了吧！！那么，笔者便不再多讲了！！

那么，请看笔者用递归写的中序遍历二叉树的简单代码吧！！

    //中序遍历打印二叉搜索树！
    public void inorder(TreeNode root){
        if (root==null){
            return;
        }
        inorder(root.left);
        System.out.println(root.val);
        inorder(root.right);
    }

对于二叉搜素树的重难点来了！！请注意看！！ 4.二叉搜索树的删除操作！

对于二叉搜索树的删除操作，我们大致可以分为七种！！注意是七种！！！

那么，接下来，请跟着笔者的思路来走进二叉搜索树的删除环节吧！！

假设删除节点为cur，待删除节点的双亲节点为parent 1.cur.left==null（大前提）

1.cur是root,则root==cur.right

6f493a158c72d4d6626820b661ea2445.png 2.cur不是root，cur是parent.left，则parent.left=cur.right

7c66b0238738d4e7fb86b6d859990cc0.png 3.cur不是root，cur是parent.right，则parnet.right=cur.right

c5b387d16e87596ead4389ced4d83fd5.png 2.cur.right==null（大前提）

1.cur是root，则root=cur.left

4970a1c187a34a6adda5d3fec79cf2b5.png 2. cur不是root，cur是parent.left，则parent.left=cur.left

7e6903361d85e8276d3b250d10ef78e1.png 3.cur不是root，cur是parent.right，则parent.right=cur.left

1f9704f5db24e211bc05c8d8e9d718fe.png 3.cur.left != null && cur.right != null （大前提）

对于这种，确实有点儿难度！！但是，我们可以采用替换法来进行删除！！通过将右子树的最小节点/左子树的最大节点与需要删除的节点值进行交换！！（一般用右子树的最小节点）

421cd521618f9c20071ea65e778b4183.png 假设，对于上述的二叉搜索树，我们要进行删除100，则可以用95/107进行替换（以107为列）——>右子树最小的元素，则最后就变换为怎样删除107这个元素了！！！

那么，有了上述的几个分析，可以跟着笔者来看一下代码如何实现！！

    //删除节点为val的值！
    public  void remove(int val){
        TreeNode cur=root;//cur记录当前要删除的节点
        TreeNode parent=null;//当前要删除节点的父亲节点！
        while (cur!=null){
            if (cur.val==val){
                removeNode(parent,cur);//删除
            }else if (cur.val<val){
                parent=cur;
                cur=cur.right;
            }else {
                parent=cur;
                cur=cur.right;
            }
        }
    }
    
    private void removeNode(TreeNode parent,TreeNode cur){
        if (cur.left==null){//左边为空的情况
            if (cur==root){
                root=cur.right;
            }else if (parent.left==cur){
                parent.left=cur.right;
            }else {
                parent.right=cur.right;
            }
        }else if (cur.right==null){//右边为空的情况
            if (cur==root){
                root=cur.left;
            }else if (parent.left==cur){
                parent.left=cur.left;
            }else {
                parent.right=cur.left;
            }
        }else {//两边都不为空的情况
            TreeNode target=cur.right;
            TreeNode targetParent=cur;
            //cur是要删除的节点
            //targetParent是要删除节点的父亲节点
            while (target.left !=null){
                targetParent=target;
                target=target.left;
            }
            cur.val=target.val;//替换
            if (target==targetParent.left){
                targetParent.left=target.right;
            }else {
                targetParent.right=target.right;
            }
        }
    }

对于该段代码比较复杂!!

那么，请见笔者的所有代码！！

BinarySearchTree.java文件！！

import java.awt.dnd.peer.DropTargetPeer;
 
public class BinarySearchTree {
    static class TreeNode{
        //定义静态内部类
        public int val;
        public TreeNode left;
        public TreeNode right;
 
        //构造方法！
        public TreeNode(int val) {
            this.val = val;
        }
    }
 
    //定义一个根节点
    public TreeNode root=null;
 
    public TreeNode find(int val){
        TreeNode cur=root;
 
        while (cur!=null){
            if (cur.val<val){
                cur=cur.right;//右边查找，左边的数据已经pass了！
            }else if (cur.val==val){
                return cur;
            }else {
                cur=cur.left;//左边查找，右边数据已经pass了！
            }
        }
        //循环走完了，左右两边的数据都没有找到！
        return null;
    }
 
    //插入一个数据
    public void insert(int val){
        if (root==null){
            return;
        }
 
        TreeNode cur=root;
        TreeNode parent=null;
 
        while (cur !=null){
            if (cur.val<val){
                parent=cur;
                cur=cur.right;
            }else if (cur.val==val){
                return;
                //二叉搜素树中，不要有两个一样的数据，这样没意义！
            }else {
                parent=cur;
                cur=cur.left;
            }
        }
 
        //当出while循环的时候，此时cur==null
        //将要插入的数据进行实列化节点！
        TreeNode node=new TreeNode(val);
        //判断一下新的节点是插入在左边还是插入在右边！
        if (parent.val<val){
            parent.right=node;
        }else {
            parent.left=node;
        }
    }
 
    //中序遍历打印二叉搜索树！
    public void inorder(TreeNode root){
        if (root==null){
            return;
        }
        inorder(root.left);
        System.out.println(root.val);
        inorder(root.right);
    }
 
    //删除节点为val的值！
    public  void remove(int val){
        TreeNode cur=root;//cur记录当前要删除的节点
        TreeNode parent=null;//当前要删除节点的父亲节点！
        while (cur!=null){
            if (cur.val==val){
                removeNode(parent,cur);//删除
            }else if (cur.val<val){
                parent=cur;
                cur=cur.right;
            }else {
                parent=cur;
                cur=cur.right;
            }
        }
    }
 
    private void removeNode(TreeNode parent,TreeNode cur){
        if (cur.left==null){//左边为空的情况
            if (cur==root){
                root=cur.right;
            }else if (parent.left==cur){
                parent.left=cur.right;
            }else {
                parent.right=cur.right;
            }
        }else if (cur.right==null){//右边为空的情况
            if (cur==root){
                root=cur.left;
            }else if (parent.left==cur){
                parent.left=cur.left;
            }else {
                parent.right=cur.left;
            }
        }else {//两边都不为空的情况
            TreeNode target=cur.right;
            TreeNode targetParent=cur;
            //cur是要删除的节点
            //targetParent是要删除节点的父亲节点
            while (target.left !=null){
                targetParent=target;
                target=target.left;
            }
            cur.val=target.val;//替换
            if (target==targetParent.left){
                targetParent.left=target.right;
            }else {
                targetParent.right=target.right;
            }
        }
    }
 
 
}

Test.java文件！！

public class Test {
    public static void main(String[] args) {
        BinarySearchTree binarySearchTree=new BinarySearchTree();
        binarySearchTree.insert(12);
        binarySearchTree.insert(21);
        binarySearchTree.insert(5);
        binarySearchTree.insert(18);
        binarySearchTree.insert(9);
 
        //打印节点——》中序遍历
        binarySearchTree.inorder(binarySearchTree.root);
 
        //查找12是否在二叉搜索树中
        BinarySearchTree.TreeNode ret=binarySearchTree.find(12);
        System.out.println(ret);
 
        //删除节点为13的值
        binarySearchTree.remove(13);
        binarySearchTree.inorder(binarySearchTree.root);
    }
}

上述便是代码的全部内容，感兴趣的老铁，请……嗯！三联哟！！

avatar
文章
阅读
粉丝