Golang数据结构: 二叉搜索树

最新推荐文章于 2023-07-11 16:38:34 发布
最新推荐文章于 2023-07-11 16:38:34 发布
阅读量357 收藏 1
点赞数
分类专栏： Golang 文章标签： 数据结构 二叉树 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neweastsun/article/details/107747361
版权

Golang数据结构: 二叉搜索树

树用于表示层次结构，比较好理解的类比是家族关系树。和哈希表或图结构一样，属于非连续数据结构。

二叉树是每个节点最多只有两个子节点。二叉搜索树的特性是左节点的值小于右节点，它是非常有用的数据结构，用于有效地存储和索引数据，以及数据检索。

1. 功能描述

1.1 术语

根节点：树的第顶级(零级)节点
子节点：树中除了根节点的节点
内部节点：每个节点至少有一个子节点
叶子节点：没有子节点的节点
子树：以某个节点作为根的节点集

1.2 方法说明

二叉树结构一般需要以下方法：

  • Insert(t) 在树中插入原始
  • Search(t) 如果树中存在该元素则返回true
  • InOrderTraverse() 按照中序方式遍历所有
  • PreOrderTraverse() 按照前序方式遍历所有
  • PostOrderTraverse() 按照后序方式遍历所有
  • Min() 返回树中最小元素
  • Max() 返回树中最大元素
  • String() 在命令行下渲染树

我们将创建ItemBinarySearchTree泛型，并发安全的数据结构。可以使用genny生成具体类型树实现，其中封装包括特定值数据结构。

首先定义节点结构体：

type Node struct {
    key   int
    value Item
    left  *Node //left
    right *Node //right
}

key对应值可以是任意数据类型Item类型，key类型这里使用int类型，实际可以是任何能进行比较的数据类型。

在树中插入元素需要使用递归，因为需要为其找到合适的位置。规则是如果节点的key小于当前节点，如果其没有左子节点则作为其左子节点，否则使用其左子节点作为当前节点重新计算。又子节点规则一样。

遍历是遍历树所有节点的过程，提供三种方法实现。以这棵二叉搜索树为例:

  • 中序：查找最小节点，即最左边叶子节点，然后访问该节点。然后继续至链接至当前节点的下一个最小节点。遍历顺序为：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11

  • 前序：访问子节点之前，首先访问当前节点：8 -> 4 -> 2 -> 1 -> 3 -> 6 -> 5 -> 7 -> 10 -> 9 -> 11

  • 后续节点：查找最小节点，即最左边叶子节点，然后处理兄弟节点，再是父节点。接着至下一个子树并向上遍历父节点：1 -> 3 -> 2 -> 5 -> 7 -> 6 -> 4 -> 9 -> 11 -> 10 -> 8

String方法，用于测试，通过打印节点信息让用户通过可视化方式检查。

------------------------------------------------
                     ---[ 1
              ---[ 2
                     ---[ 3
       ---[ 4
                     ---[ 5
              ---[ 6
                     ---[ 7
---[ 8
              ---[ 9
       ---[ 10
              ---[ 11
------------------------------------------------

2. 实现

这里主要说下删除逻辑，给定键删除对应节点。

如果待删除key小于当前节点key，则设当前节点为其左节点并递归调用自身。如果大于当前节点，则设当前节点为其右节点并递归调用自身。

直到两者key相等，则找到对应要删除的节点。如果找不到则直接返回nil。

删除节点有分几种情况。

  1. 没有子节点
    直接设置该节点为nil，返回该节点。
  2. 有一个子节点
    如果左节点为nil，则让该节点为其右节点。如果右节点为nil，让该节点为其左节点。然后返回该节点。
  3. 有两个子节点
    最复杂的是这种情况。
    因为可能节点还有其子节点。我们找到有子子树中的最小节点作为当前节点，然后删右边最小节点，最后返回该节点。
package tree

import (
	"fmt"
	"github.com/cheekybits/genny/generic"
	"sync"
)

// 定义泛型
type Item generic.Type

// 树节点结构体
type Node struct {
	key   int
	value Item
	left  *Node //left
	right *Node //right
}

// 二叉搜索树结构体
type ItemBinarySearchTree struct {
	root *Node
	lock sync.RWMutex
}

// 插入元素
func (bst *ItemBinarySearchTree) Insert(key int, value Item) {
	bst.lock.Lock()
	defer bst.lock.Unlock()
	n := &Node{key, value, nil, nil}
	if bst.root == nil {
		bst.root = n
	} else {
		insertNode(bst.root, n)
	}
}

// 从node开始查找位置并插入新节点
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)
		}
	}
}

// 中序遍历
func (bst *ItemBinarySearchTree) InOrderTraverse(f func(Item)) {
	bst.lock.RLock()
	defer bst.lock.RUnlock()
	inOrderTraverse(bst.root, f)
}

// internal recursive function to traverse in order
func inOrderTraverse(n *Node, f func(Item)) {
	if n != nil {
		inOrderTraverse(n.left, f)
		f(n.value)
		inOrderTraverse(n.right, f)
	}
}

// 前序遍历
func (bst *ItemBinarySearchTree) PreOrderTraverse(f func(Item)) {
	bst.lock.Lock()
	defer bst.lock.Unlock()
	preOrderTraverse(bst.root, f)
}

// internal recursive function to traverse pre order
func preOrderTraverse(n *Node, f func(Item)) {
	if n != nil {
		f(n.value)
		preOrderTraverse(n.left, f)
		preOrderTraverse(n.right, f)
	}
}

// 后续遍历
func (bst *ItemBinarySearchTree) PostOrderTraverse(f func(Item)) {
	bst.lock.Lock()
	defer bst.lock.Unlock()
	postOrderTraverse(bst.root, f)
}

// internal recursive function to traverse post order
func postOrderTraverse(n *Node, f func(Item)) {
	if n != nil {
		postOrderTraverse(n.left, f)
		postOrderTraverse(n.right, f)
		f(n.value)
	}
}

// 查找最小元素节点
func (bst *ItemBinarySearchTree) Min() *Item {
	bst.lock.RLock()
	defer bst.lock.RUnlock()
	n := bst.root
	if n == nil {
		return nil
	}
	for {
		if n.left == nil {
			return &n.value
		}
		n = n.left
	}
}

// 查找最大元素节点
func (bst *ItemBinarySearchTree) Max() *Item {
	bst.lock.RLock()
	defer bst.lock.RUnlock()
	n := bst.root
	if n == nil {
		return nil
	}
	for {
		if n.right == nil {
			return &n.value
		}
		n = n.right
	}
}

// 搜索指定key的节点
func (bst *ItemBinarySearchTree) Search(key int) bool {
	bst.lock.RLock()
	defer bst.lock.RUnlock()
	return search(bst.root, key)
}

// internal recursive function to search an item in the tree
func search(n *Node, key int) bool {
	if n == nil {
		return false
	}
	if key < n.key {
		return search(n.left, key)
	}
	if key > n.key {
		return search(n.right, key)
	}
	return true
}

// 删除指定key的节点
func (bst *ItemBinarySearchTree) Remove(key int) {
	bst.lock.Lock()
	defer bst.lock.Unlock()
	remove(bst.root, key)
}

// internal recursive function to remove an item
func remove(node *Node, key int) *Node {
	if node == nil {
		return nil
	}
	if key < node.key {
		node.left = remove(node.left, key)
		return node
	}
	if key > node.key {
		node.right = remove(node.right, key)
		return node
	}
	// key == node.key
	if node.left == nil && node.right == nil {
		node = nil
		return nil
	}
	if node.left == nil {
		node = node.right
		return node
	}
	if node.right == nil {
		node = node.left
		return node
	}
	minRightNode := node.right
	for  minRightNode.left != nil {
		//find smallest value on the right side
		minRightNode = minRightNode.left
	}
	node.key, node.value = minRightNode.key, minRightNode.value
	node.right = remove(node.right, node.key)

	return node
}

// 以字符串方式打印树
func (bst *ItemBinarySearchTree) String() {
	bst.lock.Lock()
	defer bst.lock.Unlock()
	fmt.Println("------------------------------------------------")
	stringify(bst.root, 0)
	fmt.Println("------------------------------------------------")
}

// internal recursive function to print a tree
func stringify(n *Node, level int) {
	if n != nil {
		format := ""
		for i := 0; i < level; i++ {
			format += "       "
		}
		format += "---[ "
		level++
		stringify(n.right, level)
		fmt.Printf(format+"%d\n", n.key)
		stringify(n.left, level)
	}
}

3. 测试

package tree

import (
	"fmt"
	"testing"
)

var bst ItemBinarySearchTree

func fillTree(bst *ItemBinarySearchTree) {
	bst.Insert(8, "8")
	bst.Insert(4, "4")
	bst.Insert(10, "10")
	bst.Insert(2, "2")
	bst.Insert(6, "6")
	bst.Insert(1, "1")
	bst.Insert(3, "3")
	bst.Insert(5, "5")
	bst.Insert(7, "7")
	bst.Insert(9, "9")
}

func TestInsert(t *testing.T) {
	fillTree(&bst)
	bst.String()

	bst.Insert(11, "11")
	bst.String()
}

func TestRemove(t *testing.T) {
	fillTree(&bst)
	bst.String()

	bst.Remove(4)
	bst.String()
}

当然我们可以利用genny生成具体类型。

genny -in binarysearchtree.go -out binarysearchtree-int.go gen "Item=int"

4. 总结

本文实现了Golang版本的二叉搜索树。删除操作相对复杂，这里只实现了右侧最小节点，读者还可以尝试左边最大节点。

梦想画家
关注
专栏目录
题98. 验证二叉搜索树
漠宸离若的博客
05-05 217
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例1: 输入: 2 / \ 1 3 输出: true 示例2: 输入: 5 / \ 1 4 / \ ...
golang 实现二叉搜索树（面向对象，非递归）
Jinhua_Wei的博客
03-11 494
二叉搜索树 golang 实现非递归方式的二叉搜索树（OO）。 实现时以index为索引比较，data中记录节点数据。 实现方法： 1. 二叉树中插入节点（Insert）； 2. 二叉树中查找节点 (Search)； 3. 二叉树中删除节点(Delete) —&gt;需要考虑多种情况: 没有任何子树，只有左或右子树，同时有左子树和右子树； 二叉搜索不是平衡树，搜索最坏情况(n),最好...
【二叉树算法】golang-二叉搜索树
weixin_41198062的博客
05-07 257
二叉搜索树 二叉搜索树是一个有序树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树 ......
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_30900589的博客
08-14 173
数据结构 首先我们定义需要的数据结构。注意，TreeNode的左右节点都是TreeNode type的，而树只有一个Root数据域，为TreeNode type type TreeNode struct { Value int Left *TreeNode Right *TreeNode } type BinarySearchTree struct { Root *Tr...
golang 实现二叉树遍历
lucky404的博客
06-16 2263
前序遍历 前序遍历的顺序是 根 -----> 左子树 -----> 右子树 中序遍历 中序遍历的顺序是 左子树 -----> 根 ------> 右子树 后序遍历 后序遍历的顺序是 左子树 -----> 右子树 -----> 根 package main import "fmt" // 二叉树的数据结构 type TreeNode struct {...
【Golang】用 go 实现二叉搜索树
smx_dd的博客
05-25 529
今日周六，闲来无事，正好最近学习了go语言，就用go实现了一个简单的二叉搜索树，用于练习，支持插入和删除操作。 package main import ( "fmt" ) type TreeNode struct { Value int Left *TreeNode Right *TreeNode } func CreateNode(value int) *TreeNode {...
有序链表转换二叉搜索树 golang
Jason_hj11的博客
11-21 461
有序链表转换二叉搜索树 /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode
二叉搜索树的实现(Go描述)
01-08
二叉搜索树的结构如下: // Binary Search Tree type BST struct { // Data interface{} 替换为interface可以支持多种数据类型 Val int Left *BST Right *BST } 实现如下操作: 查找(递归/非递归) 删除 插入 ...
data-structures:队列、堆栈、单向链表、二叉搜索树和图的 Go 实现
06-23
Go中实现的数据结构 在复习实现不同的数据结构...二叉搜索树 首先导入BST包： import "github.com/fabioberger/data-structures/bst" 创建一棵树并插入一些值： tree := bst.NewTree(8, nil) // 2nd param is for
二叉搜索树(golang)
weixin_42815827的博客
12-28 493
二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：
golang实现二叉查找树
skh2015java的博客
02-02 1201
二叉树：每个节点至多有两个子节点 二叉查找树的特点：对于每一个节点X,左子树中所有项的值小于X中的值，而它的右子树种所有项的值大于X中的值。 二叉查找树是特殊的二叉树 以下用代码实现 type binarySearchTree struct { value int left,right *binarySearchTree } //初始化并添加根节点的值 f
数据结构STL——golang实现二叉搜索树Binary Search Tree
l2975的博客
12-25 329
github仓库存储地址：https://github.com/hlccd/goSTL 概述 ​ 二叉搜索树（Binary Search Tree）不同于之前使用的线性结构，它是一种通过离散的多个点以指针的形式连接起来的树形结构。 ​ 二叉树由一个根节点和根节点下属的多层次的子结点构成，任意一个结点最多只能拥有两个子结点，即左右子结点。基于此种特性，在实现二叉搜索树时，可以仅持有根节点，然后通过根节点去递归访问其子结点以实现寻找到所有结点的。 ​ 对于二叉搜索树，由于其中缀表达式是有序的，即从小到大（
Go语言实现二叉查找树(Binary Search Trees)
拙言的专栏
02-01 2743
官网有一个二叉排序树的例子，在此基础上增加了查找和删除节点功能。    代码:   package main //Binary Search Trees //author: Xiong Chuan Liang //date: 2015-2-1 import ( "fmt" "math/rand" ) func main() { t := New(10, 1) if Searc
Golang 数据结构：二叉搜索树
最新发布
憧憬个人博客
07-11 194
Insert(v) // 向二叉搜索树的合适位置插入节点 Search(k) // 检查序号为 k 的元素在树中是否存在 Remove(v) // 移除树中所有值为 v 的节点 Min() // 获取二叉搜索树中最小的值 Max() // 获取二叉搜索树中最大的值 InOrderTraverse() // 中序遍历树 PreOrderTraverse() // 先序遍历树 PostOrderTraverse() // 后续遍历树 String() // 在命令行格式化打印出二叉树。
Go实现二叉查找树
Coding changes the world
02-24 388
-----------------------------------------binarysearchtree.go----------------------------------------package binarysearchtree import ( "fmt" "container/list" "errors" ) var ( ErrComparato...
算法：java与golang的二叉搜索树
OceanStar的博客
06-02 251
树的操作 创建树 销毁树 前序遍历树 中序遍历树 后序遍历树 层次遍历树 求叶子节点[度为0]个数 求二叉树第K层节点个数 求二叉树第K层节点个数 递归代码 // 需要一个数节点 public class TreeNode<T> { T value; TreeNode leftChild; TreeNode rightChild; public TreeNode() { } public TreeNode(T value) {
golang ----------- 二叉排序树
田园园野的博客
05-14 788
二叉排序树又叫二叉搜索树，二叉查找树主要在删除时：分两种情况：1、如果被删除结点只有一个子结点，就直接将A的子结点连至A的父结点上，并将A删除2、如果被删除结点有两个子结点，将该结点右子数内的最小结点取代A。代码：package main import "fmt" type BST struct { left *BST value int right *BST } //查找元素 fun...
golang实现binarySearch
dibao6752的博客
11-05 129
二分查找法 golang收获 获取随机数， 先设置一个随机时间 rand.Seed(time.Now()).UnixNano()), 然后执行rand.Intn(2<<16)可以获得随机数； 递归的实现，针对二分查找过程应该数 (](]的区间，中间一个数<=, 然后是 < 算法执行过程 通过一个数组，对里面的内容进行二分查找，数组的大小有2^16，里面为有序的...
用golang写一个二叉搜索树
06-07
下面是用 Golang 实现的二叉搜索树代码，包括节点结构体和基本的插入和查找操作： ```go package main import ( "fmt" ) // 节点结构体 type Node struct { Key int // 关键字 Left *Node // 左子节点 Right *Node // 右子节点 } // 插入节点 func (n *Node) Insert(key int) { if n.Key < key { if n.Right == nil { n.Right = &Node{Key: key} } else { n.Right.Insert(key) } } else if n.Key > key { if n.Left == nil { n.Left = &Node{Key: key} } else { n.Left.Insert(key) } } } // 查找节点 func (n *Node) Search(key int) bool { if n == nil { return false } if n.Key < key { return n.Right.Search(key) } else if n.Key > key { return n.Left.Search(key) } return true } func main() { root := &Node{Key: 5} // 根节点 root.Insert(3) root.Insert(8) root.Insert(2) root.Insert(4) root.Insert(7) root.Insert(9) fmt.Println(root.Search(5)) // true fmt.Println(root.Search(2)) // true fmt.Println(root.Search(6)) // false fmt.Println(root.Search(10)) // false } ``` 在这个代码中，我们使用 `Node` 结构体来表示二叉搜索树的节点，包括 `Key` 关键字、`Left` 左子节点和 `Right` 右子节点。在 `Insert` 方法中，我们根据关键字的大小来决定插入到左子树还是右子树，并递归地调用子节点的 `Insert` 方法。在 `Search` 方法中，我们通过递归查找子树来寻找目标节点。最后，在主函数中，我们创建了一个根节点，插入了几个节点，并查找了一些关键字。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值