本篇,我们用go简单的实现二叉查找树。

1.节点定义

type BSNode struct{
data int
left, right, parent *BSNode
}

2.前序遍历

func (p *BSNode) PreTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} fmt.Printf("%d ", p.data)
if p.left != nil {
p.left.PreTraverse()
}
if p.right != nil {
p.right.PreTraverse()
}
return nil
}

3.中序遍历

func (p *BSNode) InTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} if p.left != nil {
p.left.InTraverse()
}
fmt.Printf("%d ", p.data)
if p.right != nil {
p.right.InTraverse()
}
return nil
}

4.后序遍历

func (p *BSNode) PostTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} if p.left != nil {
p.left.PostTraverse()
}
if p.right != nil {
p.right.PostTraverse()
}
fmt.Printf("%d ", p.data)
return nil
}

5.添加节点

func (p *BSNode) Add(data int) error {
if data == 0 {
return errors.New("Error: not support 0 value!")
}
if p.data == 0 {
p.data = data
return nil
}
if p.data == data {
return errors.New("Error: add repeated data!")
} else if data < p.data {
if p.left == nil {
p.left = new(BSNode)
p.left.data = data
p.left.parent = p
return nil
}
p.left.Add(data)
} else {
if p.right == nil {
p.right = new(BSNode)
p.right.data = data
p.right.parent = p
return nil
}
p.right.Add(data)
}
return nil
}

6.删除节点

func (p *BSNode) Delete(data int) {
bsnode := p.Find(data)
if bsnode == nil {
return
}
if bsnode.left != nil {
var tmp *BSNode
for bsnode.left != nil {
bsnode.data = bsnode.left.data
tmp = bsnode
bsnode = bsnode.left
}
tmp.left = nil
return
}
if bsnode.right != nil {
var tmp *BSNode
for bsnode.right != nil {
bsnode.data = bsnode.right.data
tmp = bsnode
bsnode = bsnode.right
}
tmp.right = nil
return
}
if bsnode.parent != nil {
if bsnode.parent.left == bsnode {
bsnode.parent.left = nil
} else {
bsnode.parent.right = nil
}
} }

7.查询节点

func (p *BSNode) Find(data int) *BSNode {
if p.data == data {
return p
} else if data < p.data {
if p.left != nil {
return p.left.Find(data)
}
return nil
} else {
if p.right != nil {
return p.right.Find(data)
}
return nil
}
}

8.测试代码

func main() {
num := []int{50, 20, 60, 40, 80, 10, 55, 52, 56} var root *BSNode = new(BSNode)
for _, v := range num {
root.Add(v)
} fmt.Println("前序遍历:")
root.PreTraverse()
fmt.Printf("\n") fmt.Println("中序遍历:")
root.InTraverse()
fmt.Printf("\n") fmt.Println("后序遍历:")
root.PostTraverse()
fmt.Printf("\n") bsnode := root.Find(60)
if bsnode != nil {
fmt.Println("查询结果:")
fmt.Printf("节点:%d 父节点:%d 左子节点:%d 右子节点:%d\n", bsnode.data, bsnode.parent.data, bsnode.left.data, bsnode.right.data)
} root.Delete(50)
fmt.Println("删除后前序遍历:")
root.PreTraverse()
fmt.Printf("\n") }

9.完整代码

package main

import (
"fmt"
"errors"
) type BSNode struct{
data int
left, right, parent *BSNode
} // 前序遍历
func (p *BSNode) PreTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} fmt.Printf("%d ", p.data)
if p.left != nil {
p.left.PreTraverse()
}
if p.right != nil {
p.right.PreTraverse()
}
return nil
} // 中序遍历
func (p *BSNode) InTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} if p.left != nil {
p.left.InTraverse()
}
fmt.Printf("%d ", p.data)
if p.right != nil {
p.right.InTraverse()
}
return nil
} // 后序遍历
func (p *BSNode) PostTraverse() error{
if p.data == 0 {
return errors.New("Error: no data!")
} if p.left != nil {
p.left.PostTraverse()
}
if p.right != nil {
p.right.PostTraverse()
}
fmt.Printf("%d ", p.data)
return nil
} // 添加节点
func (p *BSNode) Add(data int) error {
if data == 0 {
return errors.New("Error: not support 0 value!")
}
if p.data == 0 {
p.data = data
return nil
}
if p.data == data {
return errors.New("Error: add repeated data!")
} else if data < p.data {
if p.left == nil {
p.left = new(BSNode)
p.left.data = data
p.left.parent = p
return nil
}
p.left.Add(data)
} else {
if p.right == nil {
p.right = new(BSNode)
p.right.data = data
p.right.parent = p
return nil
}
p.right.Add(data)
}
return nil
} // 删除节点
func (p *BSNode) Delete(data int) {
bsnode := p.Find(data)
if bsnode == nil {
return
}
if bsnode.left != nil {
var tmp *BSNode
for bsnode.left != nil {
bsnode.data = bsnode.left.data
tmp = bsnode
bsnode = bsnode.left
}
tmp.left = nil
return
}
if bsnode.right != nil {
var tmp *BSNode
for bsnode.right != nil {
bsnode.data = bsnode.right.data
tmp = bsnode
bsnode = bsnode.right
}
tmp.right = nil
return
}
if bsnode.parent != nil {
if bsnode.parent.left == bsnode {
bsnode.parent.left = nil
} else {
bsnode.parent.right = nil
}
} } // 查询节点
func (p *BSNode) Find(data int) *BSNode {
if p.data == data {
return p
} else if data < p.data {
if p.left != nil {
return p.left.Find(data)
}
return nil
} else {
if p.right != nil {
return p.right.Find(data)
}
return nil
}
} func main() {
num := []int{50, 20, 60, 40, 80, 10, 55, 52, 56} var root *BSNode = new(BSNode)
for _, v := range num {
root.Add(v)
} fmt.Println("前序遍历:")
root.PreTraverse()
fmt.Printf("\n") fmt.Println("中序遍历:")
root.InTraverse()
fmt.Printf("\n") fmt.Println("后序遍历:")
root.PostTraverse()
fmt.Printf("\n") bsnode := root.Find(60)
if bsnode != nil {
fmt.Println("查询结果:")
fmt.Printf("节点:%d 父节点:%d 左子节点:%d 右子节点:%d\n", bsnode.data, bsnode.parent.data, bsnode.left.data, bsnode.right.data)
} root.Delete(50)
fmt.Println("删除后前序遍历:")
root.PreTraverse()
fmt.Printf("\n") }

(二)用go实现二叉查找树的更多相关文章

  1. [BinaryTree] 二叉搜索树(二叉查找树、二叉排序树)

    二叉查找树(BinarySearch Tree,也叫二叉搜索树,或称二叉排序树BinarySort Tree)或者是一棵空树,或者是具有下列性质的二叉树: (1)若它的左子树不为空,则左子树上所有结点 ...

  2. OBST(Optimal Binary Tree最优二叉搜索树)

    二叉搜索树 二叉查找树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的 ...

  3. 二叉查找树 C++实现(含完整代码)

    一般二叉树的查找是通过遍历整棵二叉树实现,效率较低.二叉查找树是一种特殊的二叉树,可以提高查找的效率.二叉查找树又称为二叉排序树或二叉搜索树. 二叉查找树的定义 二叉排序树(Binary Search ...

  4. 二叉查找树(binary search tree)详解

    二叉查找树(Binary Search Tree),也称二叉排序树(binary sorted tree),是指一棵空树或者具有下列性质的二叉树: 若任意节点的左子树不空,则左子树上所有结点的值均小于 ...

  5. 【算法】二叉查找树实现字典API

    参考资料 <算法(java)>                           — — Robert Sedgewick, Kevin Wayne <数据结构>       ...

  6. C++版 - 剑指offer 面试题24:二叉搜索树BST的后序遍历序列(的判断) 题解

    剑指offer 面试题24:二叉搜索树的后序遍历序列(的判断) 题目:输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果.如果是则返回true.否则返回false.假设输入的数组的任意两个 ...

  7. 【算法】二叉查找树(BST)实现字典API

    参考资料 <算法(java)>                           — — Robert Sedgewick, Kevin Wayne <数据结构>       ...

  8. [LeetCode系列]卡特兰数(Catalan Number) 在求解独特二叉搜寻树(Unique Binary Search Tree)中的应用分析

    本文原题: LeetCode. 给定 n, 求解独特二叉搜寻树 (binary search trees) 的个数. 什么是二叉搜寻树? 二叉查找树(Binary Search Tree),或者是一棵 ...

  9. 数据结构与算法——优先队列类的C++实现(二叉堆)

    优先队列简单介绍: 操作系统表明上看着是支持多个应用程序同一时候执行.其实是每一个时刻仅仅能有一个进程执行,操作系统会调度不同的进程去执行. 每一个进程都仅仅能执行一个固定的时间,当超过了该时间.操作 ...

  10. 【数据结构05】红-黑树基础----二叉搜索树(Binary Search Tree)

    目录 1.二分法引言 2.二叉搜索树定义 3.二叉搜索树的CRUD 4.二叉搜索树的两种极端情况 5.二叉搜索树总结 前言 在[算法04]树与二叉树中,已经介绍过了关于树的一些基本概念以及二叉树的前中 ...

随机推荐

  1. .net NPOI Excel导入:时间格式2022/5/26导入变成26-5月-2022

    1.问题由来 在做一个导入的需求时,测试导入模板,无论导入模板里的日期设置成何种日期格式到代码中都会提示有不正确的格式化数据,加断点调试发现,导入的日期如:Excel表格中是2022/5/26,断点看 ...

  2. UBUNTU18.04安装Pangolin

    https://github.com/stevenlovegrove/Pangolin

  3. vue跨域请求数据

    vue跨域请求数据 本篇文章基于vue-cli编写 问题描述 当出现如下关键词,证明我们正在执行跨域问题 此时证明我们违背了同源策略(即协议名.ip.端口号一致) 环境准备 首先,要想实现跨域请求数据 ...

  4. Angular 利用路由快照实现tab

    1.定义路由快照 新建文件SimpleReuseStrategy.ts import { RouteReuseStrategy, DefaultUrlSerializer, ActivatedRout ...

  5. 通过post请求添加员工信息到数据库

    HMTL部分 js部分

  6. 98、TypeError: f.upload.addEventListener is not a function

    https://blog.csdn.net/qq_42202633/article/details/123083927 在分片上传时遇到的这个问题

  7. sqlserver 通过.mdf 和.ldf 恢复数据库

    USE master;GOCREATE DATABASE ImageManager ON (FILENAME = 'D:\LD\计时器demo\winform图片上传DB\ImageManager.m ...

  8. 前端回血day24 flex子项伤的CSS属性

    取值 含义 order 可以通过设置order改变某一个flex子项的排序位置.所有flex子项的默认order属性值是0 flex-grow 属性中的grow是扩展的意思,扩展的就是flex子项所占 ...

  9. R代码

    决策树 library(tree) tree.car <- tree(High ~ . - Sales, data = Carseats) #去除scales然后构造决策树 Logistic回归 ...

  10. TensorFlow中的Variable 变量

    简单运用 这节课我们学习如何在 Tensorflow 中使用 Variable . 在 Tensorflow 中,定义了某字符串是变量,它才是变量,这一点是与 Python 所不同的. 定义语法: s ...