二叉搜索树的实现

简介: 二叉搜索树的实现

@TOC

什么是搜索树?

二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树:

1.若它的左子树不为空,则左子树上所有节点的值都小于根节点的值
2.若它的右子树不为空,则右子树上所有节点的值都大于根节点的值
3.它的左右子树也分别为二叉搜索树

在这里插入图片描述

查找操作

在这里插入图片描述
这里我们定义一个cur指针用来遍历搜索树。

//查找key是否存在
    public TreeNode search(int key) {
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                return cur;
            }else if(cur.key > key){
                cur = cur.left;
            }else {
                cur = cur.right;
            }
        }
        return null;
    }

插入操作

  1. 如果树为空树,即根 == null,直接插入

在这里插入图片描述

  1. 如果树不是空树,按照查找逻辑确定插入位置,插入新结点

在这里插入图片描述
定义一个cur去遍历搜索树,parent用来记录cur的上一位置,如果该结点大于key则遍历左子树,小于遍历右子树,等于直接退出(搜索树不允许出现相同的数值)。

public boolean insert(int key) {
        if(root == null) {
            root = new TreeNode(key);
        }
        TreeNode prev = null;
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                return false;
            }else if(cur.key > key) {
                prev = cur;
                cur = cur.left;
            }else {
                prev = cur;
                cur = cur.right;
            }
        }
        if(prev.key > key) {
            prev.left = new TreeNode(key);
        }else {
            prev.right = new TreeNode(key);
        }
        return true;
    }

删除操作

设待删除结点为 cur, 待删除结点的双亲结点为 parent

分三种情况:
1.cur.left == null

  1. cur 是 root,则 root = cur.right
  2. cur 不是 root,cur 是 parent.left,则 parent.left = cur.right
  3. cur 不是 root,cur 是 parent.right,则 parent.right = cur.right

2.cur.right == null

  1. cur 是 root,则 root = cur.left
  2. cur 不是 root,cur 是 parent.left,则 parent.left = cur.left
  3. cur 不是 root,cur 是 parent.right,则 parent.right = cur.left

3. cur.left != null && cur.right != null
需要使用替换法进行删除,即在它的右子树中寻找中序下的第一个结点(关键码最小),用它的值填补到被删除节点中,再来处理该结点的删除问题

第一和第二种情况相对比较简单,改变一下parent的指向即可,我们具体讨论一下第三种情况。

在这里插入图片描述
如果我们想从上面的 搜索树 中删除 15,我们可以做一些技巧来将情况减少到情况 1 或情况 2
1.求其右子树的最小值
2.求其左子树的最大值
在这里插入图片描述
我们可以发现我们只需要找到右子树的最左的,或者左子树最右的和cur交换即可,不影响搜索树的顺序。

public boolean remove(int key) {
        TreeNode prev = null;
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                removeChild(prev,cur);
                return true;
            }else if(cur.key > key) {
                prev = cur;
                cur = cur.left;
            }else {
                prev = cur;
                cur = cur.right;
            }
        }
        return false;
    }
    public  void removeChild(TreeNode parent,TreeNode cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = root.right;
            } else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = root.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            TreeNode target = cur.right;
            TreeNode targetParent = cur;
            while(target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }

实现

public class BinarySearchTree {
    static class TreeNode {
        public int key;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int key) {
            this.key = key;
        }

        @Override
        public String toString() {
            return "TreeNode{" +
                    "key=" + key +
                    '}';
        }
    }

    public TreeNode root;

    /**
     * 插入一个元素
     */
    public boolean insert(int key) {
        if(root == null) {
            root = new TreeNode(key);
        }
        TreeNode prev = null;
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                return false;
            }else if(cur.key > key) {
                prev = cur;
                cur = cur.left;
            }else {
                prev = cur;
                cur = cur.right;
            }
        }
        if(prev.key > key) {
            prev.left = new TreeNode(key);
        }else {
            prev.right = new TreeNode(key);
        }
        return true;
    }

    public  void inOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        inOrder(root.left);
        System.out.println(root.key + " ");
        inOrder(root.right);
    }
    //查找key是否存在
    public TreeNode search(int key) {
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                return cur;
            }else if(cur.key > key){
                cur = cur.left;
            }else {
                cur = cur.right;
            }
        }
        return null;
    }

    public boolean remove(int key) {
        TreeNode prev = null;
        TreeNode cur = root;
        while(cur != null) {
            if(cur.key == key) {
                removeChild(prev,cur);
                return true;
            }else if(cur.key > key) {
                prev = cur;
                cur = cur.left;
            }else {
                prev = cur;
                cur = cur.right;
            }
        }
        return false;
    }
    public  void removeChild(TreeNode parent,TreeNode cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = root.right;
            } else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = root.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            TreeNode target = cur.right;
            TreeNode targetParent = cur;
            while(target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
}
目录
相关文章
|
1天前
|
数据采集 人工智能 安全
|
11天前
|
云安全 监控 安全
|
2天前
|
自然语言处理 API
万相 Wan2.6 全新升级发布!人人都能当导演的时代来了
通义万相2.6全新升级,支持文生图、图生视频、文生视频,打造电影级创作体验。智能分镜、角色扮演、音画同步,让创意一键成片,大众也能轻松制作高质量短视频。
985 151
|
2天前
|
编解码 人工智能 机器人
通义万相2.6,模型使用指南
智能分镜 | 多镜头叙事 | 支持15秒视频生成 | 高品质声音生成 | 多人稳定对话
|
16天前
|
机器学习/深度学习 人工智能 自然语言处理
Z-Image:冲击体验上限的下一代图像生成模型
通义实验室推出全新文生图模型Z-Image,以6B参数实现“快、稳、轻、准”突破。Turbo版本仅需8步亚秒级生成,支持16GB显存设备,中英双语理解与文字渲染尤为出色,真实感和美学表现媲美国际顶尖模型,被誉为“最值得关注的开源生图模型之一”。
1686 8
|
8天前
|
人工智能 自然语言处理 API
一句话生成拓扑图!AI+Draw.io 封神开源组合,工具让你的效率爆炸
一句话生成拓扑图!next-ai-draw-io 结合 AI 与 Draw.io,通过自然语言秒出架构图,支持私有部署、免费大模型接口,彻底解放生产力,绘图效率直接爆炸。
630 152
|
10天前
|
人工智能 安全 前端开发
AgentScope Java v1.0 发布,让 Java 开发者轻松构建企业级 Agentic 应用
AgentScope 重磅发布 Java 版本,拥抱企业开发主流技术栈。
602 15
|
9天前
|
人工智能 自然语言处理 API
Next AI Draw.io:当AI遇见Draw.io图表绘制
Next AI Draw.io 是一款融合AI与图表绘制的开源工具,基于Next.js实现,支持自然语言生成架构图、流程图等专业图表。集成多款主流大模型,提供智能绘图、图像识别优化、版本管理等功能,部署简单,安全可控,助力技术文档与系统设计高效创作。
679 151