自己写GoBinarySearchTree 二叉查找树

GO指南-练习:等价二叉查找树 在大多数语言中,检查两个二叉树是否保存了相同序列的函数都相当复杂。我们将使用 Go 的并发和信道来编写一个简单的解法。不同二叉树的叶节点上可以保存相同的值序列。例如,以下两个二叉树都保存了序列 `1,1,2,3,5,8,13`。用于构造一个随机结构的已排序二叉查找树,它保存了值。然后从信道中读取并打印 10 个值。是否存储了相同的值。 阅读详情

前言:

  java GoBinarySearchTree的简易实现,代码中注释比较详尽,通俗易懂,注意事项亦在注解中标明。

正文:

  1. GoBinarySearchTree.java

    package com.anteoy.dataStructuresAndAlgorithm.javav2.my;
    
    /**
     * Created by zhoudazhuang on 17-3-2.
     * Description: AnyType extends Comparable<? super AnyType>
     * 注意这里的extends 接口 不能使用implements AnyType已经是泛型 不能使用
     * compareTo这里是多态 root节点在插入过程中是变化的 如在root1 中插入节点root2
     */
    public class GoBinarySearchTree<AnyType extends Comparable<? super AnyType>> {
    
        //根节点
        private BinaryNode<AnyType> root;
    
        /**
         * 节点存储tuple
         * @param <AnyType>
         */
        private static class BinaryNode<AnyType> {
            //节点存储的数据
            AnyType element;
            //左子节点
            BinaryNode<AnyType> left;
            //右子节点
            BinaryNode<AnyType> right;
    
            BinaryNode(AnyType theElement) {
                this(theElement, null, null);
            }
    
            //构造注入
            BinaryNode(AnyType theElement, BinaryNode<AnyType> lt,
                       BinaryNode<AnyType> rt) {
                element = theElement;
                left = lt;
                right = rt;
            }
        }
    
        public GoBinarySearchTree() {
            makeEmpty();
        }
    
        /**
         * 使树为空树
         */
        public void makeEmpty() {
            root = null;
        }
    
        /**
         * 该树是否为空树
         *
         * @return 是否空
         */
        public boolean isEmpty() {
            return root == null;
        }
    
        /**
         * 该树是否存在含有参数值的节点
         *
         * @param value
         *            元素值
         * @return 是否含该元素
         */
        public boolean contains(AnyType value) {
            return contains(value, root);
        }
    
        /**
         * node节点及其子节点是否有value这个值
         * @param value
         * @param node
         * @return
         */
        private boolean contains(AnyType value, BinaryNode<AnyType> node) {
            //传入节点为空 如果不判断 则可能出现空指针异常 最后如果查找到最后一个节点 没有节点了还是没有找到 则返回false
            if (node == null) {
                return false;
            }
    
            //多态分发compareTo
            int compareResult = value.compareTo(node.element);
            // 如果比node.element小,根据二叉查找树,递归查找左子树下
            if (compareResult < 0) {
                return contains(value, node.left);
                //和上面相反 这里可以解释为尾递归,但java编译器实则为对尾递归进行优化
            } else if (compareResult > 0) {
                return contains(value, node.right);
            } else {
                return true;
            }
        }
    
        /**
         * 查找树的最小元素值
         * @return 最小元素值
         */
        public AnyType findMin() {
            if (isEmpty()) {
                throw new NullPointerException();
            }
            //返回最小节点的元素值
            return findMin(root).element;
        }
    
    
        /**
         * 查找以node为树的最小子节点
         * @param node root节点
         * @return 最小子节点
         */
        private BinaryNode<AnyType> findMin(BinaryNode<AnyType> node) {
            if (node == null) {
                return null;
                //最小节点
            } else if (node.left == null) {
                return node;
            }
            //尾递归查找最左边的后代节点 直到node.left == null
            return findMin(node.left);
        }
    
        /**
         * 查找该树最大元素值
         * @return 最大元素值
         */
        public AnyType findMax() {
            if (isEmpty()) {
                throw new NullPointerException();
            }
            return findMavalue(root).element;
        }
    
    
    
        /**
         * 查找某节点及其子树中的最大元素 这里使用while循环替代递归 递归方法在下面注解中给出
         * @param root
         * @return
         */
        private BinaryNode<AnyType> findMavalue(BinaryNode<AnyType> root) {
            if(root != null){
                while (root.right != null){
                    root = root.right;
                }
            }
            //如果root为空 会直接返回root即null 所以不用赘余判断
            return root;
        }
        //递归方法
    //    private BinaryNode<AnyType> findMavalue(BinaryNode<AnyType> root) {
    //        if (root == null) {
    //            return null;
    //        } else if (root.right == null) {
    //            return root;
    //        }
    //        return findMavalue(root.right);
    //    }
    
        /**
         * 插入元素
         * @param value
         */
        public void insert(AnyType value) {
            root = insert(value, root);
        }
    
        /**
         * root node下插入元素value
         * @param value
         * @param root
         * @return 元素插入的节点
         */
        private BinaryNode<AnyType> insert(AnyType value, BinaryNode<AnyType> root) {
            //1. 空树直接返回一个节点 2. 递归终结条件  binaryNode.left 或者binaryNode.right为空了 new一个节点(树叶)并返回 到下面 root.left = insert(v
            if (root == null) {
                return new BinaryNode<AnyType>(value);
            }
            //和root节点比较大小
            int compareResult = value.compareTo(root.element);
            //往左边递归计算 root节点重新分配  这里构造关联关系
            if (compareResult < 0) {
                root.left = insert(value, root.left);
            //和上面相反
            } else if (compareResult > 0) {
                root.right = insert(value, root.right);
            }
            return root;
        }
    
        /**
         * 删除某元素
         * @param value
         */
        public void remove(AnyType value) {
            root = remove(value, root);
        }
    
        /**
         * 在某个节点下删除元素
         * @param value
         * @param root
         * @return 被删除元素的节点
         */
        private BinaryNode<AnyType> remove(AnyType value, BinaryNode<AnyType> root) {
            if (root == null) {
                return root;
            }
            int compareResult = value.compareTo(root.element);
            //如果是左子树
            if (compareResult < 0) {
                //递归到最左边
                root.left = remove(value, root.left);
            } else if (compareResult > 0) {
                //相反
                root.right = remove(value, root.right);
                //情况一 此节点左右两个儿子都存在
            } else if (root.left != null && root.right != null) {//root此时就是要求被删除节点
                //查找右边的节点的最小值 和被删除节点交换
                root.element = findMin(root.right).element;
                //交换完毕 设置右边的值为删除以后的节点的右子节点的最小值
                root.right = remove(root.element, root.right);
            } else {
                //该节点只有左右儿子中的其中一个 直接使用唯一儿子代替
                root = (root.left != null) ? root.left : root.right;
            }
            return root;
        }
    
        /**
         * 遍历输出树
         */
        public void printTree() {
            if (isEmpty()) {
                System.out.println("Empty tree");
            } else {
                printTree(root);
            }
        }
    
        /**
         * 递归输出打印
         * 先输出最小的左子节点 在在每一个递归回归里面 进行递归右边节点的操作
         * 达到由小到大输出
         * @param root
         */
        private void printTree(BinaryNode<AnyType> root) {
            if (root != null) {
                printTree(root.left);
                System.out.println(root.element);
                printTree(root.right);
            }
        }
    
    }
  2. GoBinarySearchTreeTest.java

    package com.anteoy.dataStructuresAndAlgorithm.javav2.my;

/**
 * Created by zhoudazhuang on 17-3-2.
 * GoBinarySearchTreeTest
 */
public class GoBinarySearchTreeTest {
    public static void main(String[] args) {
        GoBinarySearchTree<Integer> tree = new GoBinarySearchTree<Integer>();
        tree.insert(2);
        tree.insert(1);
        tree.insert(5);
        tree.insert(4);
        tree.insert(3);
        tree.printTree();
        System.out.println(" ");
        tree.remove(2);
        tree.remove(4);
        tree.printTree();
    }
}

输出结果:

1
2
3
4
5

1
3
5

Process finished with exit code 0

后记:

  1. 参考文献:数据结构与算法分析
Golang以OO的方式实现二叉查找树 二叉查找树是一种满足如下性质的二叉树: (1)  某个节点的左子树中的所有节点的值都比这个节点的值小 (2)  某个节点的右子树中的所有节点的值都比这个节点的值大 下面有Go实现的非常详尽的代码,采用了Go风格的OO进行了封装。代码中主函数的例子的参照图如下: 实现代码: package main import ( "fmt" ) type TreeNode 阅读详情

相关推荐

《Go官方指南》(并发)练习:等价二叉查找树

练习:等价二叉查找树: 题目原链接 方法一:使用go 思路: 准备两个信道 两棵树分别同时写入自己的信道,写入一个数据后立刻读出数据 (为使该步骤顺利进行,需要将两个Walk加上go) 对比读出的数据,一旦数据不同 return false 为什么选择没有缓冲的信道? 防止出现ch1在读出第1个数据,ch2已经在读出第2个数据的情况,那样会误判为数据不一样return false package main import ( "fmt" "golang.org/x/tour/tree" )

皮特儿的博客 1001

Go语言练习:等价二叉查找树

Same(tree.New(1), tree.New(1)) 应当返回 true,而 Same(tree.New(1), tree.New(2)) 应当返回 false。在这里主要忘记了在信道里面没有数据的时候,取数据的线程会被自动阻塞,所以在same函数中无需判断是否有数据,直接读取即可。函数 tree.New(k) 用于构造一个随机结构的已排序二叉查找树,它保存了值 k, 2k, 3k, …应当是数字 1, 2, 3, …用 Walk 实现 Same 函数来检测 t1 和 t2 是否存储了相同的值。

qq_42053724的博客 230

golang官方指导练习(go tour exercise)

golang官方练习的pass代码,使用了中文版的tour

掠雪墨影的随记 8054

GO指南 练习:等价二叉查找树

【代码】GO指南 练习:等价二叉查找树。

OneSeek的博客 527

详细解读文字识别工具———Tesseract-OCR

   在尝试破解12306验证码的时候,提前了解了一下应对各种验证码的解决方案,这里主要是学习到了面对文字图片验证码,例如亚马逊、豆瓣等平台的登录时会遇到的情况,效果还不错。 一、工具介绍 ​    Tesseract-OCR 是一款由HP实验室开发由Google维护的开源OCR(Optical Character Recognition...

别看我只是一只羊 2万+

告别第三方插件:官方Fused Library如何重塑Android库的合并与发布流程

本文详细介绍了Android官方推出的Fused Library如何替代第三方fat-aar插件,优化Android库的合并与发布流程。通过原生支持、智能依赖管理等优势,Fused Library解决了版本兼容性、依赖传递等核心痛点,提供了更稳定高效的开发体验。文章还提供了迁移实操指南和工程实践建议,帮助开发者顺利过渡到官方方案。

weixin_42561040的博客 259

Go指南练习之《等价二叉树》(Equivalent Binary Trees)

Go官网指南 练习原文 实现 WordCount。它应当返回一个含有 s 中每个 “词” 个数的 map。函数 wc.Test 针对这个函数执行一个测试用例,并输出成功还是失败。 你会发现 strings.Fields 很有帮助。 关键信息 如:”I am a boy ha ha ” 用strings.Fields()来获取分割的信息,以[]byt

BigManing的博客 8816

低成本实现webhook接收端[python]

Webook本质上也是API,只不过是反向调用,即前端不主动发送请求,完全由后端推送。简单来说,Webhook是一个接受HTTP POST或是GET,PUT,DELETE的URL,一个实现了Webhook的API提供商就是在当事件发生的时候会向配置的URL发送信息,与请求-响应式不同,使用Webhook可以实时接收到变化。Ps:Webhook可能会发出大量的请求,确保接受的URL不被泄露或者应用能及时处理这些请求。

锡城小凯的博客 1万+

学习 Go 语言 0x0c:《Go 语言之旅》中 练习 等价二叉查找树

★ 题目 https://tour.go-zh.org/concurrency/7 https://tour.go-zh.org/concurrency/8 练习: 等价二叉查找树 不同二叉树的叶节点上可以保存相同的值序列。例如,以下两个二叉树都保存了序列 1,1,2,3,5,8,13。 在大多数语言中,检查两个二叉树是否保存了相同序列的函数都相当复杂。 我们将使用 Go 的并发和信道来编写一个...

Abracadabra的专栏 1221

【语音识别算法】深度学习语音识别算法与传统语音识别算法的区别、对比及联系

深度学习语音识别算法与传统语音识别算法在理论基础、实现方式、性能表现等方面存在显著区别,同时也有一些联系。下面将从几个方面详细比较这两种方法,并给出应用实例和代码示例。

weixin_51306394的博客 2571

LTspice进阶技巧-031.一键加密仿真模型:LTspice Encrypt Tool实战指南

本文详细介绍了LTspice Encrypt Tool的使用方法,帮助工程师一键加密LTspice仿真模型,保护知识产权。通过图形化界面简化操作流程,支持批量加密和兼容性处理,适用于电路设计中的模型保护需求。

weixin_28304023的博客 204

golang 实现 等价查找二叉树

刚接触go语言半年,日常工作都是用小组内自研的going框架开发,对golang底层的并发机制并不是非常熟悉,近期特地研究了一下,简单实现个小算法 不同二叉树的叶节点上可以保存相同的值序列。例如,以下两个二叉树都保存了序列 `1,1,2,3,5,8,13`。 在大多数语言中,检查两个二叉树是否保存了相同序列的函数都相当复杂。 我们将使用 Go 的并发和信道来编写一个简单的解法。 本例使用...

diu_brother的博客 956

用户视角下的vfsglobal预约困境:从注册到登录的全流程避坑指南

本文详细解析了vfsglobal签证预约系统从注册到登录的全流程操作,帮助用户避开常见技术陷阱。针对IP限制、DNS解析、浏览器缓存等登录障碍提供实用解决方案,并揭示账号管理的隐藏规则与支付环节的延时处理技巧,助力用户高效完成签证预约。

ol78901234的博客 876

svn: E155007 和 svn: E155004

###引言:   环境:ubuntu 16.04 svn: 一个为IDEA插件版本 一个install 版本 情景:命令行下 svn: E155007 not a working copy ;IDEA插件下 svn: E155004 is already locked 处理: 尝试命令行下使用 svn cleanup结果:svn: E155007 not a working copy 尝试

Anteoy的博客 2万+

材料带隙预测(图神经网络)(⭐⭐)—— 用晶体图网络预测钙钛矿材料的能带隙,加速光伏材料筛选。技术栈:CGCNN、MEGNet、Materials Project数据集

钙钛矿太阳能电池以其高效率、低成本的优势迅速崛起,但传统“试错法”材料筛选效率极低,严重制约了光伏技术的迭代速度。近年来,基于图神经网络的材料带隙预测方法,特别是晶体图神经网络(CGCNN)和材料图网络(MEGNet),为这一问题提供了革命性的解决方案。本文系统梳理了材料带隙预测从传统计算到深度学习的演进历程,深入剖析了CGCNN与MEGNet的架构设计、数学原理及创新机制,详细阐述了Materials Project数据集的构建、特征工程与处理策略。

2201_76125393的博客 51

Python FastAPI 面试题及参考答案

FastAPI 的路由机制是其核心功能之一,用于将不同的 URL 路径映射到相应的处理函数。通过定义路由,可以构建出功能丰富的 API。在 FastAPI 中,使用装饰器来定义路由。在这个示例中,是一个装饰器,它将根路径"/"的 GET 请求映射到read_root函数。当客户端发送一个 GET 请求到根路径时,FastAPI 会调用read_root函数并返回结果。

大模型大数据攻城狮的专栏 2255

ubuntu16.04 自动挂载新分区到指定目录下

引言:  起因:ubuntu系统使用固态硬盘120G不够使用,如今已无法满足日常需要,于是增加了一枚机械硬盘,分别分了两个空闲分区,依次使系统自启时挂在到/home/和/usr/指定目录下安装环境: ubuntu 16.04 LTS 有剩余未分配空间的硬盘 安装过程: 查看硬盘所有分区并记录下待挂在分区(主要以硬盘,分区大小和格式确定) fdisk -l 格式化分区为ext4 mkfs.

Anteoy的博客 1万+

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

nginx搭配frp进行端口和服务转发

引言:  java接入三方运营商服务接口,需要可供回调的公网接口,并在本地两台(及以上)调试接口服务,于是使用开源frp进行穿透,nginx搭配负责分发请求到不同机器。安装环境: ubuntu 16.04 LTS 一台服务器 两台客户机 已安装好nginx frp配置过程:参考我之前博文[http://blog.youkuaiyun.com/yan_chou/article/details/53406095](

Anteoy的博客 1万+

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

ubuntu 16.04安装zookeeper

搭建环境 ubuntu 16.04 LTS zookeeper-3.5.1-alpha 搭建过程使用官方源码包进行安装 资源准备zookeeper-3.5.1-alpha.tar.gz 源码包 官方稳定版下载地址http://apache.fayea.com/zookeeper/ 开始安装解压压缩包到指定目录tar -zxvf zookeeper-3.5.1-alpha.tar.gz -C /h

Anteoy的博客 1万+

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

git本地版本落后仓库几个版本pull冲突相关

git中本地落后仓库几个版本pull冲突,但是自己又不想提交本地的代码到远程仓库,可以尝试使用下面的方法: 一种是使用git fetch,但是自己这个用得少 另外就是使用git pull git pull = git fetch + git merch 解决冲突时利用git stash 把本地代码保存起来 1.git pull origin master 报错:有冲突 不能拉取下来(本

Anteoy的博客 5314

java collection Iterator的remove()方法

事情是这样的,今天在项目里用spring data jpa hibernate的SearchFilter返回一个List<Object>的时候,由于需求需要,必须再使用一定条件过滤部分元素,开始想iterator.remove()方法三下五除二就能解决,结果就悲剧了,前前后后搞了近一小时。下面上代码,同时记录一下:   Specification<Lawyer> specification = D

Anteoy的博客 4432

CAfile:/etc/ssl/certs/ca-certificates.crt CRLfile:none

问题描述 CAfile:/etc/ssl/certs/ca-certificates.crt CRLfile:none ubuntu 16.04 git https 解决方案 export GIT_SSL_NO_VERIFY = 1 sudo update-ca-certificates echo -n | openssl s_client -showcerts -connect github.co

Anteoy的博客 4365

nginx配置分发tomcat服务

搭建环境: ubuntu 16.04 LTS apache tomcat 7 java 7 nginx/1.10.0 (ubuntu) 搭建过程:注:本人在这里使用的是ubuntu软件源进行安装,但推荐大家实用源码包进行安装,源码安装更易后期配置,关于源码安装,可参考nginx官网文档nginx官方中文文档地址nginx gitbook官方文档地址 sudo apt install nginx

Anteoy的博客 2861

spring4 配置json *.html 出现HTTP 406问题

引起原因: spring4.x中原请求servlet-mapping为/ 拦截所有请求 需要修改为.html,需使用spring4.x 重现: 原本是直接修改servlet-mapping /改位*.html 结果:修改为*.html过后 请求无法正常发挥Json,一直报错htpp 406 无法接受的请求头 寻找问题并解决过程 发现spring-servlet.xml的xsi原始指向位spri

Anteoy的博客 2310

java golang tcp socket导致线上服务器出现大量close_wait的完整示例

tcp断开连接的四次挥手 先说说tcp的四次挥手,这里假定A端为主动发起关闭端,B端为被动接收关闭请求端。A把tcp的数据包中标识位FIN置为1,seq为一个随机数,发送这个包给B端,自己进入FIN_WAIT_1状态;B端收到了马上给A端回复ack(A端收到ack进入FIN_WAIT_2状态),然后自己进入CLOSE_WAIT状态。然后这个时候需要业务代码处理,把自己需要发给客户端的数据发送完,然...

Anteoy的博客 2222
上一篇: 自己写Stack 实现栈结构
下一篇: 自己写GoBinaryHead 二叉堆binaryheap实现优先队列(堆)
anteoy
博客等级 码龄10年 24粉丝 83原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值