go语言实现二叉搜索树

最新推荐文章于 2022-12-28 16:14:34 发布
置顶 最新推荐文章于 2022-12-28 16:14:34 发布
阅读量655 收藏
点赞数
分类专栏： 区块链开发技术博客 文章标签： 区块链 go语言 技术 二叉树 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/companion_1314/article/details/80094586
版权

整理：张帅 博客 : one8.one

基本概念介绍

  • 树(tree) : 一种分层的数据结构，类比家谱

  • 二叉搜索树（binary tree）： 左节点的值均小于有节点的二叉树

  • 深度（depth）：从 root根结点到当前节点唯一路径的长度

  • 高度（height）：从当前节点到一片树叶最长的路径的长度

  • 根（root）：深度为0的树节点

  • 内部节点（internal node）：至少有一个字节点的节点

  • 树叶节点（leaf）：无字节点的节点

  • 兄弟节点（sibling）：拥有相同父节点的字节点波、

1-1

应用

文件系统和数据库系统一般都采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。二叉树是一种最基本最典型的排序树，对于学习和研究树的特性，但是本身很少在实际中进行应用。就像冒泡排序一样，二叉树因为效率问题并不实用。

二叉树的常用操作

  • Insert（v） //向二叉树的合适位置插入节点
  • Remove(v). // 移除树中所有值为v的节点
  • Search(v) //检查值为v的元素是否在树中
  • Min(). //获取二叉树中最小的值
  • Max() //获取二叉树中最大的值
  • InOrderTraverse() //中序遍历树
  • PreOrderTraverse() //先序遍历树
  • PostOrderTraverse() //后序遍历树
  • String() //在命令行格式化打印出二叉树

同样适用genny提供代码的复用性，树类型命名为：ItemBinarySearchTree,树节点的结构体定义如下：

在命令端使用 
go get "github.com/cheekybits/genny/generic" 
命令获取这个包

import (
    "fmt"
    "sync"

    "github.com/cheekybits/genny/generic"  
)


type Item generic.Type   //generic.Type 为"github.com/cheekybits/genny/generic"这个包下面的一个空接口类型，type为generic.Type起别名为Item

type Node struct{
    key        int    //中序遍历的节点序号
    value      Item   //节点存储的值
    left       *Node  //左节点
    right      *Node   //右面节点
}

插入操作与遍历

插入操作需要使用到递归，插入操作需要从上到下的查找新节点在树中合适的位置，新节点的值小于任意节点，则向左子树继续寻找，同理向右子树寻找，直到树叶节点再插入。

遍历操作有三种方式：

  • 中序遍历（in-order）：左子树（L）–>根节点(D）–>右树（R）1->2->3->4->5->6->7->8->9->10- >11 （LDR）

  • 先序遍历（pre-order）：根节点（D）–>左子树（L）–>右树（R） 8->4->2->1->3->6->5->7 >10->9- >11。（DLR）

  • 后序遍历（pre-order）：左子树(L)–>右子树（R）–>根节点（D） 8->4->2->1->3->6->5->7 >10->9- >11 （LRD）

根据根节点的位置来看是什么序列遍历

1-2

String() 可视化树结构

1-3

代码实现

Insert

//向二叉树合适的位置插入节点
func (tree *ItemBinarySearchTree) Insert(key int, value Item) {

//为了确保操作二叉树的数据安全，对数据操作进行读写上锁
    tree.lock.Lock()
    defer tree.lock.Unlock()
    newNode := &Node{key, value, nil, nil}
//如果当前的树为空，那么插入的节点作为根节点
    if tree.root == nil {
        tree.root = newNode
    } else {
    //调用下面的插入函数，另起一个方法
        insertNode(tree.root, newNode)
    }

}

//找到合适的位置
func insertNode(node, newNode *Node) {

//当新节点的值小于节点的值的时候，应该插入到节点的左侧
    if newNode.key < node.key {
    //如果旧节点左侧没有节点，那么旧节点直接赋值新节点
        if node.left == nil {
            node.left = newNode
        } else {
        //否则将左节点作为老节点，继续寻找左节点的左节点
            insertNode(node.left, newNode)
        }
    } else {
    //与上面同理
        if node.right == nil {
            node.right = newNode
        } else {
            insertNode(node.right, newNode)
        }
    }

}

Search

//检查key的元素是否存在
func (tree *ItemBinarySearchTree) Search(key int) bool {

    tree.lock.Lock()
    defer tree.lock.Unlock()
    return search(tree.root, key)

}
func search(node *Node, key int) bool {

    if node == nil {
        return false
    }
  //如果key的值小于节点的值，那么应该插入到左子树
    if key < node.key {
    //将左子树作为新节点，继续查询
        return search(node.left, key)
    }

    // 如果key的值大于节点的值，那么应该插入右子树
    if key > node.key {
    //将右子树作为新节点，继续查询
        return search(node.right, key)
    }

//如果当前key的值==node.key 返回true
    return true

}

Remove

删除节点的流程

先递归查找，再删除节点。但是在删除时需要根据节点拥有子节点的数量，分如下3中情况：

代码实现

func (tree *ItemBinarySearchTree) remove(key int) {

    tree.lock.Lock()
    defer tree.lock.Unlock()
    remove(tree.root, key)

}

func remove(node *Node, key int) *Node {
    if node == nil {
        return nil
    }

   // 如果key< node.key 则向左寻找

    if key < node.key {

        // 将左节点作为新节点递归继续寻找

        node.left = remove(node.left, key)
        return node
    }

    // 如果key> node.key 则向右寻找

    if key > node.key {

    // 将右节点作为新节点递归继续寻找

        node.right = remove(node.right, key)
        return node
    }

//如果key==node.key 判断node有没有左右子树，如果没有，则直接删除
    if node.left == nil && node.right == nil {

        node = nil
        return node
    }
//如果key==node.key 判断node有没有左右子树，如果有右子树，则将右子树直接赋值给当前节点，完成覆盖删除
    if node.left == nil {
        node = node.right
        return node
    }

    //如果key==node.key 判断node有没有左右子树，如果有右子树，则将右子树直接赋值给当前节点，完成覆盖删除

    if node.right == nil {
        node = node.left
        return node
    }

    mostLeftMode := node.right
// 要删除的节点有2个字节点，找到右子树的最左节点，替换当前节点
for {

    //一直遍历找到最左节点
        if mostLeftMode != nil && mostLeftMode.left != nil {
            mostLeftMode = mostLeftMode.left
        } else {
            break
        }

    }

// 使用右子树的最左节点替换当前的节点，即删除当前节点
    node.key, node.value = mostLeftMode.key,mostLeftMode.value

    node.right = remove(node.right, node.key)

    return node

}

Max

//获取最大节点即为二叉树最右节点，根据二叉树的性质

func (tree *ItemBinarySearchTree) Max() *Item {

    tree.lock.Lock()
    defer tree.lock.Unlock()
    node := tree.root
    if node == nil {
        return nil
    }
    for {

        if node.right == nil {
            return &node.value
        }

        node = node.right
    }

}

Min


// 根据二叉树的性质,获取最大节点即为二叉树最右节点

func (tree *ItemBinarySearchTree) Min() *Item {

    tree.lock.Lock()
    defer tree.lock.Unlock()

    node := tree.root

    if node == nil {
        return nil
    }

    for {
        if node.left == nil {
            return &node.value
        } else {
            node = node.left
        }

    }

}

Traverse


// 先序遍历：根节点 -> 左子树 ->右子树
func (tree *ItemBinarySearchTree) PreOrderTraverse(printFunc func(Item)) {

    tree.lock.Lock()
    defer tree.lock.Unlock()

    preOrderTraverse(tree.root, printFunc)

}

func preOrderTraverse(node *Node, printFunc func(Item)) {

    if node != nil {
    //先打印根节点
        printFunc(node.value)

        //然后递归调用自己，将左节点作为新节点，打印
        preOrderTraverse(node.left, printFunc)
        //然后递归调用自己，将右节点作为新节点，打印
        preOrderTraverse(node.right, printFunc)

    }

}

// 中序遍历： 左子树 ->根节点 ->右子树
func (tree *ItemBinarySearchTree) PostOrderTraverse(printFunc func(Item)) {

    tree.lock.Lock()
    defer tree.lock.Unlock()

    postOrderTraverse(tree.root, printFunc)

}

func postOrderTraverse(node *Node, printFunc func(Item)) {

    if node != nil {
    //递归调用自己，将左节点作为新节点，打印
        preOrderTraverse(node.left, printFunc)
        //打印根节点
        printFunc(node.value)
        //递归调用自己，将右节点作为新节点，打印
        preOrderTraverse(node.right, printFunc)

    }

}


// 后序遍历： 左子树  ->右子树->根节点

func (tree *ItemBinarySearchTree) InOrderTraverse(printFunc func(Item)) {

    tree.lock.Lock()
    defer tree.lock.Unlock()

    inOrderTraverse(tree.root, printFunc)

}

func inOrderTraverse(node *Node, printFunc func(Item)) {

    if node != nil {
     //递归调用自己，将左节点作为新节点，打印
        preOrderTraverse(node.left, printFunc)
        //递归调用自己，将右节点作为新节点，打印
        preOrderTraverse(node.right, printFunc)
        //打印根节点
        printFunc(node.value)

    }

}

String


//后序遍历打印树的结构
func (tree *ItemBinarySearchTree) String() {
    tree.lock.Lock()
    defer tree.lock.Unlock()
    if tree.root == nil {
        println("Tree is empty")
        return
    }
    stringify(tree.root, 0)
    println("----------------------------")
}
func stringify(node *Node, level int) {
    if node == nil {
        return
    }
    format := ""
    for i := 0; i < level; i++ {
        format += "\t" // 根据节点的深度决定缩进长度

    }
    format += "----[ "
    level++
    //  先递归打印左子树
    stringify(node.left, level)
    // 打印值
    fmt.Printf(format+"%d\n", node.key) 
    //再递归打印右子树
     stringify(node.right, level)
}

总结

对于二叉树的操作，增删查都与递归相关，所以实现的时候一定要分析清楚递归的终止条件，在正确的条件下return，避开死循环。

Companion_1314
关注
专栏目录
Java:实现二叉搜索树类算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-29 192
Java:实现二叉搜索树类算法（附完整源码）
python:实现二叉搜索树算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-19 450
python:实现二叉搜索树算法(附完整源码)
二叉搜索树的实现(Go描述)
01-08
二叉搜索树的结构如下: // Binary Search Tree type BST struct { // Data interface{} 替换为interface可以支持多种数据类型 Val int Left *BST Right *BST } 实现如下操作: 查找(递归/非递归) 删除 插入 最大值 最小值 代码: package main // Binary Search Tree type BST struct { // Data interface{} Val int Left *BST Right
go语言实现二叉查找树相关操作
yyhnap的博客
05-28 381
一、什么是二叉查找树？ 二叉查找树满足以下特点 （1）树的左子树的值全部小于父节点的值 （2）树的右子树的值全部大于父节点的值 （3）左、右子树也分别满足条件（1）（2） （4）树上所有节点的值不能相等 ...
go二叉搜索树
幸福诗歌的博客
08-13 137
//二叉搜索树 package tree import "fmt" type Item interface{} type Node struct{ Key int Value Item left *Node right *Node } type BinarySearch interface{ Insert(key int,value Item) Min() *Ite...
Golang二叉查找树
陈鹏万里
03-07 1028
为简单起见，键值均为整型。 定义接口(tree.go)： type Tree interface { Put(k, v int) //新增或修改 Get(k int) int //查询 Delete(k int) //删除 Size() int //树的大小 Min() int //最小键 DeleteMin() //删除最小键} 二叉查找树(
二叉搜索树(golang)
最新发布
weixin_42815827的博客
12-28 495
二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：
trees:Go中一个简单的二叉搜索树实现
07-15
在 Go 语言中，我们可以用结构体来定义二叉搜索树的节点，如下所示： ```go type TreeNode struct { Key int Value interface{} Left *TreeNode Right *TreeNode } ``` 这个结构体包含了节点的关键字（Key）、...
go语言判断一棵树是否是二叉搜索树
Charliewolf的博客
09-13 909
点击个人博客，查看更多文章https://elonjelinek.github.io 二叉搜索树主要用来实现搜索操作，二叉搜索树在最坏情况下平均搜索和插入的时间复杂度为O(log n)。 在二叉搜索树中，所有左子树的节点的元素小于根节点数据，所有右子树的节点的元素大于根节点数据，并且树中的每个节点都满足该性质。 左子树所有节点的值均小于它的根节点的值； 右子树所有节点的值均大于它的根节点的...
Python 二叉搜索树
dta0502的博客
06-25 3253
树集合有三个重要的分类，树就属于其中的层级结构。大多数编程语言并没有将树作为一种标准类型包含其中，尽管如此，树还是得到了广泛的应用，它可以很自然的表示物体的集合，例如，一个文件的目录结构和一本书的目录。树的两个主要特征：（1）每个项都有多个子节点（2）除了叫做根的特殊的项，所有其他的项都只有一个父节点二叉树这里有两种极端情况：（1）分叉状，带有N个节点并且高度为N-1这样的树类似于链表列表中的一个...
Go与数据结构之二叉搜索树
hKY0fB8kZ6xY
03-02 400
简介: 利用Go语言实现二叉搜索树并为其编写单元测试 说明 本文是我读了《数据结构与算法分析 - C语言描述》后总结的二叉搜索树的实现，在本文中涉及到的代码都可以在我的Github仓库 bwangel23/LeetCode 中找到。 描述 对于二叉树中的任意节点X，它的左子树中所有关键字的值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值，那么这棵树就是一颗二叉搜索...
【Golang】用 go 实现二叉搜索树
smx_dd的博客
05-25 531
今日周六，闲来无事，正好最近学习了go语言，就用go实现了一个简单的二叉搜索树，用于练习，支持插入和删除操作。 package main import ( "fmt" ) type TreeNode struct { Value int Left *TreeNode Right *TreeNode } func CreateNode(value int) *TreeNode {...
验证二叉搜索树 go语言
s15738841819的博客
11-18 213
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输...
二叉搜索树（BST）Go实现
star_of_science的博客
12-05 963
BST定义 二叉搜索树是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 //定义二叉树节点 type TreeNode struct { Val int Left *TreeNode Right *TreeNode } //定义二叉树 type BinareSearchTree struct { Root *TreeNode } .
平衡二叉搜索树实现（go）
yjw19901214的博客
10-17 271
/** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func sortedArrayToBST(nums []int) *TreeNode { if len(nums) ==...
Go语言实现二叉搜索树
coolsunxu的博客
11-05 469
Go语言实现二叉搜索树
golang ----------- 二叉排序树
田园园野的博客
05-14 790
二叉排序树又叫二叉搜索树，二叉查找树主要在删除时：分两种情况：1、如果被删除结点只有一个子结点，就直接将A的子结点连至A的父结点上，并将A删除2、如果被删除结点有两个子结点，将该结点右子数内的最小结点取代A。代码：package main import "fmt" type BST struct { left *BST value int right *BST } //查找元素 fun...
go BinarySearch
杨文飞的博客
09-07 282
package main import ( &quot;fmt&quot; ) func main() { num := []int{1,3,4,6,7,8,10} fmt.Println(BinarySearch(num,100)) } func BinarySearch(lst []int,m int) int { low := 0 heigh := len(lst)...
golang 实现 等价查找二叉树
diu_brother的博客
02-12 847
刚接触go语言半年，日常工作都是用小组内自研的going框架开发，对golang底层的并发机制并不是非常熟悉，近期特地研究了一下，简单实现个小算法 不同二叉树的叶节点上可以保存相同的值序列。例如，以下两个二叉树都保存了序列 `1，1，2，3，5，8，13`。 在大多数语言中，检查两个二叉树是否保存了相同序列的函数都相当复杂。 我们将使用 Go 的并发和信道来编写一个简单的解法。 本例使用...
Python实现二叉搜索树：高效的Map集合实现方式
我们需要能够创建和使用一个空的二叉搜索树，然后插入键值对，并实现搜索、删除和其他操作。 在构造二叉搜索树时，我们将按照特定的顺序插入键值对，以确保树的平衡性和搜索效率。例如，在图 1 中，我们展示了一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值