go语言实现二叉排序树及其前序遍历

最新推荐文章于 2022-05-08 19:20:01 发布
最新推荐文章于 2022-05-08 19:20:01 发布
阅读量494 收藏 1
点赞数
分类专栏： go 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38020553/article/details/82752710
版权

结构  左右指针和存值的一个int  （这边其实可以再添加一个指向根节点的指针，那所有节点都可以获得根节点）

type AVL struct{
	left,right *AVL
	value int
}

获取左右节点的指针

func (a *AVL)getLeft()(*AVL)  {
	if a.left != nil{
		return a.left
	}
	return nil
}


func (a *AVL)getRight()(*AVL)  {
	if a.right != nil{
		return a.right
	}
	return nil
}

 

新建节点

func NewAVLNode(value int,left,right *AVL) *AVL {
	node := &AVL{value:value,left:left,right:right}
	return node
}

查找节点

当节点值大于所需要查找的值时，把当前节点的右节点当做根节点，然后继续向下找

当节点值小于所需要查找的值时，把当前节点的左节点当做根节点，然后继续向下找

func (root *AVL)Find(value int) (*AVL) {
	var result *AVL
	for true{
		if value > root.value {
			root = root.right
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if value < root.value{
			root = root.left
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else {
			result = root
			return result
		}
	}
	return result
}

 插入

func (root *AVL)Insert(a *AVL)  {
	for true{
		if a.value > root.value {
			if root.right == nil{
				root.right = a
				return
			}
			root = root.right

		}else if a.value < root.value{
			if root.left == nil{
				root.left = a
				//root = root1
				return
			}
			root = root.left
		}else {
			fmt.Println("元素已存在")
			return
		}
	}
}

查找元素与先序遍历

func (a *AVL)FindPrint(i int)  {
	result := a.Find(i)
	if result != nil{
		fmt.Println(result.value)
	}

}

//先序遍历
func (a *AVL)LeftPrint()  {
	if a.left != nil {
		l := a.left
		l.LeftPrint()
	}
	fmt.Println(a.value)
	if a.right != nil {
		r := a.right
		r.LeftPrint()
	}
}

//两种方法
//先序遍历
func LeftPrint(node *AVL)  {
	if node != nil {
		LeftPrint(node.left)
		fmt.Print("  ")
		fmt.Print(node.value)
		LeftPrint(node.right)
	}
}

查找前驱节点与删除元素


func (root *AVL)FindBefore(value int) (*AVL) {
	var result *AVL
	if value == root.value{
		fmt.Println("不能移除根节点")
		return nil
	}
	for true{
		if (root.right != nil && value == root.right.value )||(root.left != nil && value == root.left.value) {
			return root
		} else if value > root.value {
			root = root.right
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if value < root.value{
			root = root.left
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if root.left == nil && root .right == nil {
			fmt.Println("不存在")
			break
		}
	}
	return result
}

//删除元素

func (a *AVL)Remove1(v int)  {
	rm := a.Find(v)
	be := a.FindBefore(v)
	if rm != nil && be != nil {
		//要删除的元素的左右节点都为空
		if rm.left == nil && rm.right == nil{
			if rm.value > be.value{
				be.right = nil
			}else {
				be.left = nil
			}
		}else if rm.left == nil && rm.right != nil{
			//左节点为空 右节点不为空
			if rm.value > be.value{
				be.right = rm.right
			}else {
				be.left = rm.right
			}

		}else if rm.left != nil && rm.right == nil{
			//左节点不为空 右节点为空
			if rm.value > be.value{
				be.right = rm.left
			}else {
				be.left = rm.left
			}


		}else {
			//左节点不为空 右节点不为空

			//把前驱节点的指针断开
			if rm.value > be.value{
				be.right = nil
			}else {
				be.left = nil
			}
			//把rm.left及其下面的节点 以 rm.left 为代表作为一个整体重新插入
			a.Insert(rm.left)
			a.Insert(rm.right)
		}
	}

}

结果图

 

最后完整的代码

package main

import (
	"fmt"
	"math/rand"
)

type AVL struct{
	left,right *AVL
	value int
}

func (a *AVL)getLeft()(*AVL)  {
	if a.left != nil{
		return a.left
	}
	return nil
}


func (a *AVL)getRight()(*AVL)  {
	if a.right != nil{
		return a.right
	}
	return nil
}


func NewAVLNode(value int,left,right *AVL) *AVL {
	node := &AVL{value:value,left:left,right:right}
	return node
}

func (root *AVL)Find(value int) (*AVL) {
	var result *AVL
	for true{
		if value > root.value {
			root = root.right
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if value < root.value{
			root = root.left
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else {
			result = root
			return result
		}
	}
	return result
}


func (root *AVL)Insert(a *AVL)  {
	for true{
		if a.value > root.value {
			if root.right == nil{
				root.right = a
				return
			}
			root = root.right

		}else if a.value < root.value{
			if root.left == nil{
				root.left = a
				//root = root1
				return
			}
			root = root.left
		}else {
			fmt.Println("元素已存在")
			return
		}
	}
}

func (a *AVL)FindPrint(i int)  {
	result := a.Find(i)
	if result != nil{
		fmt.Println(result.value)
	}

}

//先序遍历
func (a *AVL)LeftPrint()  {
	if a.left != nil {
		l := a.left
		l.LeftPrint()
	}
	fmt.Print("  ")
	fmt.Print(a.value)
	if a.right != nil {
		r := a.right
		r.LeftPrint()
	}
}


func (root *AVL)FindBefore(value int) (*AVL) {
	var result *AVL
	if value == root.value{
		fmt.Println("不能移除根节点")
		return nil
	}
	for true{
		if (root.right != nil && value == root.right.value )||(root.left != nil && value == root.left.value) {
			return root
		} else if value > root.value {
			root = root.right
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if value < root.value{
			root = root.left
			if root == nil{
				fmt.Println("不存在")
				break
			}
		}else if root.left == nil && root .right == nil {
			fmt.Println("不存在")
			break
		}
	}
	return result
}

//删除元素

func (a *AVL)Remove1(v int)  {
	rm := a.Find(v)
	be := a.FindBefore(v)
	if rm != nil && be != nil {
		//要删除的元素的左右节点都为空
		if rm.left == nil && rm.right == nil{
			if rm.value > be.value{
				be.right = nil
			}else {
				be.left = nil
			}
		}else if rm.left == nil && rm.right != nil{
			//左节点为空 右节点不为空
			if rm.value > be.value{
				be.right = rm.right
			}else {
				be.left = rm.right
			}

		}else if rm.left != nil && rm.right == nil{
			//左节点不为空 右节点为空
			if rm.value > be.value{
				be.right = rm.left
			}else {
				be.left = rm.left
			}


		}else {
			//左节点不为空 右节点不为空

			//把前驱节点的指针断开
			if rm.value > be.value{
				be.right = nil
			}else {
				be.left = nil
			}
			//把rm.left及其下面的节点 以 rm.left 为代表作为一个整体重新插入
			a.Insert(rm.left)
			a.Insert(rm.right)
		}
	}

}



func main()  {
	//var root *AVL
	var root  = &AVL{nil,nil,50}
	//rand.Seed(time.Now().UnixNano())
	for i := 0;i<20;i++{
		v := rand.Intn(100)
		fmt.Println(v)
		node := NewAVLNode(v,nil,nil)
		root.Insert(node)
	}
	root.LeftPrint()
	root.Remove1(47)
	fmt.Println("")
	root.LeftPrint()

}

 

golang ----------- 二叉排序树
田园园野的博客
05-14 801
二叉排序树又叫二叉搜索树，二叉查找树主要在删除时：分两种情况：1、如果被删除结点只有一个子结点，就直接将A的子结点连至A的父结点上，并将A删除2、如果被删除结点有两个子结点，将该结点右子数内的最小结点取代A。代码：package main import "fmt" type BST struct { left *BST value int right *BST } //查找元素 fun...
go二叉树排序
u013235495的博客
05-31 466
    二叉树排序：一种基于二叉树的排序算法。package mainimport (    "fmt")type tree struct{    value int    left, right *tree}func Sort(values []int) {    var root *tree    for _, v := range values {        root = add(ro...
go 语言实现二叉树 前序遍历 中序遍历 后序遍历
weixin_44014995的博客
11-13 775
树的定义 树(Tree) 是 n(n>=0) 个结点的有限集, n=0 时称为空树, 在任意一颗非空树当中, 有且只有一个特定的称为根(Root) 的结点 当n>1时, 其余结点可分为 m(m>0) 个互不相交的优先集 T1 T2 … Tm, 其余每一个集合本身又是一棵树, 并且称为根的子树 (SubTree) 特别强调两点 : n>0时, 根节点是位移的, 不可能存在多个根节点 当m>0时, 子树的个数并没有限制, 但他们一定是互不相交的, 像下图的两个结构就不符
Go语言_数据结构_二叉树的三种遍历方式（前序，中序，后序）
热门推荐
数据知道的博客
07-12 3万+
二叉树的三种遍历方式： 代码实现: package main import ( "fmt" ) type Hero struct { No int Name string Left *Hero Right *Hero } //前序遍历[先输root结点，然后再输出左子树，然后再输出右子树] func PreOrder(node *Hero) { if node != nil { ...
使用golang实现二叉树,并且遍历
qq_32535455的博客
01-14 863
什么是二叉树：每个节点最多只有两个儿子节点的树 满二叉树：叶子节点与叶子节点之间的高度差为 0 的二叉树，即整棵树是满的，树呈满三角形结构。在国外的定义，非叶子节点儿子都是满的树就是满二叉树。 完全二叉树：完全二叉树是由满二叉树而引出来的，设二叉树的深度为 k，除第 k 层外，其他各层的节点数都达到最大值，且第 k 层所有的节点都连续集中在最左边。 使用Go语言定义: type TreeNode struct { Data string // 节点用来存放数据 Left *Tr.
二叉树非递归遍历算法分析
weixin_43875867的博客
05-08 1143
本文介绍了二叉树非递归遍历算法的一种实现方式，以及这种遍历算法是怎么推导出来的。
二叉排序树之Golang代码简释
smm188的博客
11-18 160
二叉排序树插入、查找、删除之Golang代码简释
二叉搜索树(BST树)
07-30 397
一、简介（1）二叉搜索树，又叫做二叉排序树，二叉查找树，有序二叉树 是指一棵空树或者具有下列性质的二叉树： 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。 左右子树都是二叉搜索树。 （2）二叉搜索树中序遍历的结果就是一个升序序列；（3）
Python 二叉搜索树
dta0502的博客
06-25 3271
树集合有三个重要的分类，树就属于其中的层级结构。大多数编程语言并没有将树作为一种标准类型包含其中，尽管如此，树还是得到了广泛的应用，它可以很自然的表示物体的集合，例如，一个文件的目录结构和一本书的目录。树的两个主要特征：（1）每个项都有多个子节点（2）除了叫做根的特殊的项，所有其他的项都只有一个父节点二叉树这里有两种极端情况：（1）分叉状，带有N个节点并且高度为N-1这样的树类似于链表列表中的一个...
平衡二叉（AVL）树
月守护的博客
12-15 1023
在前面的系列文章中，我们讲过了二叉查找树的相关知识和实现（二叉树（一）–概述（附二叉搜索树实现））。在文章的最后，我们总结了二叉查找树的查找时间复杂度： 对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度是O（logn）,和树的深度是一样的。 但对于极端情况（每次插入数据大小都是增大的，或者减小的），外形上看就只有一半的树，查找时间复杂度就会退化成O（n）的 为了解决二叉查找树查找时间复杂度退化的问题，需要二叉数据的自平衡，也就是本节要讲的平衡二叉树。通过自身的平衡调整
建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数
07-07
二叉树可执行代码，用了就知道 。 二叉树的遍历、线索及应用（ 用递归或非递归的方法都可以） [问题描述] 建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数。 [基本要求] 要求根据读取的元素建立二叉树，能输出各种遍历。 [实现提示] 可通过输入带空格的前序序列建立二叉链表。
golang使用二叉树实现排序
skh2015java的博客
11-22 1035
一个命名为S的结构体类型将不能再包含S类型的成员：因为一个聚合的值不能包含它自身。但是S类型的结构体可以包含*S指针类型的成员，这可以让我们创建递归的数据结构 func main() { fmt.Println(Sort([]int{11,2,5,30,100,10,1,70})) } type tree struct { value int left,right *tree
【golang】二叉树 前序、中序、后序 遍历
weixin_43753680的博客
07-08 245
拿下面这个树举例 牢记三种遍历的规则：注意这里面的前中后指的是跟节点的遍历顺序 先序：跟左右 中序：左右根 后序：左右跟 代码实现采用go语言，利用的递归 package main import "fmt" // 二叉树三种遍历方式 type node struct { value string leftNode *node rightNode *node } func main() { n := node{} node := n.newTree() n.bShow(no
Golang前序遍历+后序遍历(N叉树)中序遍历(二叉树) 统一规范化写法 迭代法
t949500898的博客
09-09 424
前序遍历： 采用stack（先进后出），从子节点反序灌入 /** * Definition for a Node. * type Node struct { * Val int * Children []*Node * } */ func preorder(root *Node) []int { stack := make([]*Node, 0) res := make([]int, 0) if root == nil{ return
二叉树前序遍历_golang实现好简单的二叉树前序遍历
weixin_39602615的博客
12-14 247
给定一个二叉树，返回它的前序遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,2,3]有两种通用的遍历树的策略：深度优先搜索（DFS）在这个策略中，我们采用深度作为优先级，以便从跟开始一直到达某个确定的叶子，然后再返回根到达另一个分支。深度优先搜索策略又可以根据根节点、左孩子和右孩子的相对顺序被细分为前序遍历，中序遍历...
Go语言实现二叉搜索树
coolsunxu的博客
11-05 473
Go语言实现二叉搜索树
Go实现二叉查找树
Coding changes the world
02-24 401
-----------------------------------------binarysearchtree.go----------------------------------------package binarysearchtree import ( "fmt" "container/list" "errors" ) var ( ErrComparato...
Go算法练习—二叉树的前序遍历
WatermelonMk的博客
03-12 268
二叉树的前序遍历 题目： 给定一个二叉树，返回它的前序遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 题目解答： /** * Definition for a binary tree node. * type TreeNode struct { * Val int * ...
leetcode105-Golang根据前序遍历与中序遍历构建二叉树
litchi
08-04 455
Golang根据前序遍历与中序遍历构建二叉树 执行用时：4 ms, 在所有 Go 提交中击败了95.86%的用户 内存消耗：3.9 MB, 在所有 Go 提交中击败了81.48%的用户 解题思路 前序遍历：根节点，左子树，右子树; 数组第一个元素必定是root节点 中序遍历：左子树，根节点，右子树; 利用前序遍历中找到的root节点在中序遍历中找到其对应的索引index，该index即是左子树长度 切割遍历数组: (左子树的前序遍历，左子树的中序遍历), (右子树的前序遍历，右子树的中序遍历) 递归 代
Java 实现二叉搜索树根据前序遍历、中序遍历、后序遍历写csv文件
最新发布
04-03
3. 实现二叉搜索树的遍历方法 // 前序遍历 public void preorder(TreeNode root, List<Integer> list) { if (root == null) { return; } list.add(root.val); preorder(root.left, list); preorder(root....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值