GOLANG实现的一个avl tree api

最新推荐文章于 2024-04-14 03:31:24 发布
最新推荐文章于 2024-04-14 03:31:24 发布
阅读量286 收藏
点赞数
分类专栏： Golang 文章标签： golang 数据结构 avl tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30746129/article/details/83083448
版权

用golang实现了一个avl tree的api。

avlTree.go

/*
** an avl tree api:
//==>> operator tree api:
//insert an x to AvlTree, invoker format: t = tree.Insert(t, x)
func Insert(tree *AvlNode, x ElementType) *AvlNode 
//del an x in AvlTree, invoker format: t = tree.Delete(t, x)
func Delete(tree *AvlNode, x ElementType) *AvlNode 	
//make a tree to be empty
func MakeEmpty( tree *AvlNode) *AvlNode 
//==>> print tree api:
//draw a tree
func DrawTree1(tree *AvlNode) 
//leve print a tree
func LevePrintTree(tree *AvlNode) 
//middle print a tree
func MidPrintTree(tree *AvlNode) 
//prev print a tree
func PrevPrintTree(tree *AvlNode) {
//return the height of the node
func (node *AvlNode) NodeHeight() int 
//==>> find   node  api:
//find Element x position in the avl tree
func (tree *AvlNode) Find(x ElementType) *AvlNode
//find min elem in the tree
func (tree *AvlNode) FinMin() *AvlNode 
//find max elem in the tree
func (tree *AvlNode) FinMax() *AvlNode 
*/

package tree

import (
	"fmt"
	"math"
)


type AvlNode struct {
	Elem ElementType
	Left *AvlNode
	Right *AvlNode
	Height int
}

type ElementType int

func If(condition bool, truVal, falseVal interface{}) interface{} {
	if condition {
		return truVal
	}
	return falseVal
}

//make a tree to be empty
func MakeEmpty( tree *AvlNode) *AvlNode {	
	//free left child
	if tree.Left != nil {		
		tree.Left = MakeEmpty(tree.Left)		
	}  
	//free right child
	if tree.Right != nil {
		tree.Right = MakeEmpty(tree.Right)
	} 
	//a leaf, just return nil, a gc will free the memory
	return nil	
}

func printSpace(spaceNum int) {	
	for i := 0; i < spaceNum; i++ {
		fmt.Printf("  ")
	}
}

//draw a tree
func DrawTree1(tree *AvlNode) {		
	var s [] *AvlNode
	var nextLine  *AvlNode	
	var curH int
	newLine := true		
	
	for tree != nil {		
		curH = tree.NodeHeight()		
		if nextLine == tree {			
			fmt.Println()				
			//maxLineNum = int(math.Pow(2, float64(curL)))
			newLine = true
			nextLine = nil			
		} 
		
		printSpace( int(math.Pow(2, float64(curH-1)) ) )
		
		if !newLine {
			if curH == 0 || curH == 1  {
				printSpace(1)
			} else {
				printSpace( int(math.Pow(2, float64(curH-1))) )
			}			
		} else {
			newLine = false	
			if curH == 0 {
				printSpace(1)
			}
		}			
		
		fmt.Printf("%v ", tree.Elem)
		
		if tree.Left != nil {
			if nextLine == nil {
				nextLine = tree.Left
			}
			s = append(s, tree.Left)
		}
		if tree.Right != nil {
			if nextLine == nil {
				nextLine = tree.Right
			}
			s = append(s, tree.Right)
		}
		
		if len(s) > 0 {
			tree = s[0]
			s = s[1:]
		} else {
			tree = nil
		}		
	}	
	
	fmt.Println()
}

//leve print a tree
func LevePrintTree(tree *AvlNode) {
	var s [] *AvlNode
	for tree != nil {	
		fmt.Printf("%v ", tree.Elem)
		
		if tree.Left != nil {
			s = append(s, tree.Left)
		}
		if tree.Right != nil {
			s = append(s, tree.Right)
		}
		
		if len(s) > 0 {
			tree = s[0]
			s = s[1:]
		} else {
			tree = nil
		}		
	}	
	
	fmt.Println()
	
}

//middle print a tree
func MidPrintTree(tree *AvlNode) {
	if (tree != nil ) {
		MidPrintTree(tree.Left)
		fmt.Printf(" %v ", tree.Elem)
		MidPrintTree(tree.Right)
	}	
}
//prev print a tree
func PrevPrintTree(tree *AvlNode) {
	if (tree != nil ) {
		fmt.Printf(" %v ", tree.Elem)
		PrevPrintTree(tree.Left)		
		PrevPrintTree(tree.Right)
	}	
}

//find Element x position in the avl tree
func (tree *AvlNode) Find(x ElementType) *AvlNode {
	if tree != nil {
		if x < tree.Elem {
			//find left
			return tree.Left.Find(x)
		} else if x > tree.Elem {
			//find right
			return tree.Right.Find(x)
		} else if x == tree.Elem {
			//we find that
			return tree
		}
	} 

	//can not found or empty tree
	return nil		
}

//find min elem in the tree
func (tree *AvlNode) FinMin() *AvlNode {
	if tree != nil {
		if tree.Left != nil {
			return tree.Left.FinMin()
		} else {
			return tree
		}
		
	} else {
		return nil
	}
}

//find max elem in the tree
func (tree *AvlNode) FinMax() *AvlNode {
	if tree != nil {
		if tree.Right != nil {
			return tree.Right.FinMax()
		} else {
			return tree
		}
		
	} else {
		return nil
	}
}

//return the height of the node
func (node *AvlNode) NodeHeight() int {
	if node == nil {
		return -1
	} else {
		return node.Height
	}
}

//insert an x to AvlTree, invoker format: t = tree.Insert(t, x)
func Insert(tree *AvlNode, x ElementType) *AvlNode {	
	if tree == nil {
		//tree = new(AvlNode)
		tree = &AvlNode { 
			Elem : x,			
			Height : 0,
		}
	} else if x < tree.Elem {
		tree.Left = Insert(tree.Left, x)
		if tree.Left.NodeHeight() - tree.Right.NodeHeight() == 2 {
			if x < tree.Left.Elem { //left left
				tree = singleLeftRotate(tree)
			} else { //left right
				tree = doubleRotateLeftRight(tree)
			}
		}
	} else if x > tree.Elem {
		tree.Right = Insert(tree.Right, x)
		if tree.Right.NodeHeight() - tree.Left.NodeHeight() == 2 {
			if x > tree.Right.Elem {
				tree = singleRightRotate(tree)
			} else {
				tree = doubleRotateRightLeft(tree)
			}
		}
	} else {
		//x existed, we do nothing.
	}

	tree.Height = If(tree.Left.NodeHeight() > tree.Right.NodeHeight(), 
					tree.Left.NodeHeight(), tree.Right.NodeHeight()).(int) + 1

	return tree
}

//del an x in AvlTree, invoker format: t = tree.Delete(t, x)
func Delete(tree *AvlNode, x ElementType) *AvlNode {	
	var tmp *AvlNode
	if tree != nil {
		if x < tree.Elem {
			tree.Left = Delete(tree.Left, x)	
			if tree.Right.NodeHeight() - tree.Left.NodeHeight() == 2 {
				if tree.Right.Right != nil {
					tree = singleRightRotate(tree)
				} else {
					tree = doubleRotateRightLeft(tree)
				}			
			} else {
				tree.Height = If(tree.Left.NodeHeight() > tree.Right.NodeHeight(), 
						tree.Left.NodeHeight(), tree.Right.NodeHeight()).(int) +1
			}
		} else if x > tree.Elem {
			tree.Right = Delete(tree.Right, x)
			if tree.Left.NodeHeight() - tree.Right.NodeHeight() == 2 {
				if tree.Left.Left != nil {
					tree = singleLeftRotate(tree)
				} else {
					tree = doubleRotateLeftRight(tree)
				}
							
			} else {
				tree.Height = If(tree.Left.NodeHeight() > tree.Right.NodeHeight(), 
						tree.Left.NodeHeight(), tree.Right.NodeHeight()).(int) +1
			}			
		} else if tree.Left != nil && tree.Right != nil {
			tmp = tree.Right.FinMin()
			tree.Elem = tmp.Elem
			tree.Right = Delete(tree.Right, tmp.Elem)
			
		} else {			
			if tree.Left == nil {
				tree = tree.Right
			} else if tree.Right == nil {
				tree = tree.Left
			}			
		}		
	}

	
	return tree
}

/*
//return the max height
func maxHeight(node1, node2 *AvlNode ) int {
	if node1.Height > node2.Height {
		return node1.Height
	} else {
		return node2.Height
	}	
}
*/


//left rotate a tree, and update node's height, return the new tree 
func singleLeftRotate(tree *AvlNode) *AvlNode {
	var k1 *AvlNode
	if tree != nil {
		k1 = tree.Left
		tree.Left = k1.Right
		k1.Right = tree
		
		//update height
		tree.Height = If(tree.Left.NodeHeight() > tree.Right.NodeHeight(), 
						tree.Left.NodeHeight(), tree.Right.NodeHeight()).(int) +1
		k1.Height = If(k1.Left.NodeHeight() > k1.Right.NodeHeight(), 
						k1.Left.NodeHeight(), k1.Right.NodeHeight()).(int) +1	

		tree = k1
	}

	return tree
}

//right rotate a tree, and update node's height, return the new tree
func singleRightRotate(tree *AvlNode) *AvlNode {
	var k1 *AvlNode
	if tree != nil {
		k1 = tree.Right
		tree.Right = k1.Left
		k1.Left = tree
		
		//update height
		tree.Height = If(tree.Left.NodeHeight() > tree.Right.NodeHeight(), 
						tree.Left.NodeHeight(), tree.Right.NodeHeight()).(int) +1
		k1.Height = If(k1.Left.NodeHeight() > k1.Right.NodeHeight(), 
						k1.Left.NodeHeight(), k1.Right.NodeHeight()).(int) +1	

		tree = k1
	}

	return tree
}

//k3 a tree base, k2: k3's left childe, k1: k2's right childe
//right rotate k2 & k1, left rotate k3 & k3's left child
//return a new tree
func doubleRotateLeftRight(k3 *AvlNode) *AvlNode  {
	//right rotatel between k2 & k1
	k3.Left = singleRightRotate(k3.Left)

	//left rotate between k3 and his left child
	return singleLeftRotate(k3)
}

//k3 a tree base, k2: k3's left childe, k1: k2's right childe
//left rotate k2 & k1, right rotate k3 & k3's left child
//return a new tree
func doubleRotateRightLeft(k3 *AvlNode) *AvlNode  {
	//left rotatel between k2 & k1
	k3.Right = singleLeftRotate(k3.Right)

	//right rotate between k3 and his left child
	return singleRightRotate(k3)
}

 

使用golang的test框架测试：

avlTree_test.go

package tree

import (
	"testing"
	"math/rand"
	"fmt"
	"time"	
)

func TestCreateTree(t *testing.T) {
	r := rand.New(rand.NewSource(10))	
	r.Seed(time.Now().UnixNano())
	a := r.Perm(30)	
	fmt.Println("create a slice:", a)
	var tree *AvlNode
	for _, v := range a {
		tree = Insert(tree, ElementType(v)) 
	}
		
	fmt.Println("tree created\nmidl read:")
	MidPrintTree(tree)
	fmt.Println("\nleve read:")
	LevePrintTree(tree)
	fmt.Println("\ndraw:")
	DrawTree1(tree);
	fmt.Printf("\nmin: %v, max:%v\n", tree.FinMin().Elem, tree.FinMax().Elem)		
}

测试结果：

root@ubuntu01:tree# go test
draw the avl tree:
                                16 
                5                                 21 
    1                 9         18                 25 
  0     3     7         12   17     19     23         27 
  2   4   6   8     10     14   20   22   24   26     29 
  11   13   15   28 

min: 0, max:29
PASS

【软件架构思想系列】分层架构
AI天才研究院
01-19 1万+
- 分层架构 -今天谈下架构设计中的分层思想和分层模型。架构思维概述对于架构思维本身仍然是类似系统思维，结构化思维，编程思维等诸多思维模式的一个合集。由于架构的核心作用是在业务现实世界和抽象的IT实现之间建立起一道桥梁，因此架构思维最核心的就是要：理解到业务驱动技术，技术为最终的业务服务。要真正通过架构设计来完成业务和技术，需求和实现，软件和硬件，静态和动态，成本和收益等多方面的平...
Python 接口并发测试详解
悦分享
10-23 7611
性能测试是通过自动化测试工具模拟多种正常、峰值及异常负载条件对系统的各项性能指标进行的测试。负载测试和压力测试都属于性能测试，两者可以结合进行。通过负载测试，确定在各种工作负载下系统的性能，目标是测试当负载逐渐增加时，系统各项性能指标的变化情况。压力测试是通过确定一个系统的瓶颈或者不能接受的性能点，来获得系统能提供的最大服务级别的测试。性能测试的重点是测试在并发条件下服务或系统的瓶颈所在，从而优化相关功能，可能涉及软件及硬件的多方面改进。由此可见，性能测试对整个产品非常重要，甚至可以决定一个产品是否能长久发
golang 无限级树状结构
努力的夏目_41552670
07-05 4110
package main import( "encoding/json" "fmt" ) type Datanode struct { Id int `json:"id"` ParentId int `json:"pid"` Name string `json:"name"` Child []*Datanode `json:"chi...
golang 树
wwqcherry的博客
09-11 571
使用golang来实现树的遍历 树的定义 package tree type Node struct { Val int Left *Node Right *Node } 深度优先遍历 深度优先遍历需要优先使用栈 栈的定义 type Stack struct { list *list.List } func NewStack() *Stack { list := list.New() return &Stack{list} }
go 递归tree关系_golang链表理解、递归
weixin_36047538的博客
12-29 192
1、不使用递归a. 链表间运算(逐位相加)leetcode题目 示例：输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)输出：7 -> 0 -> 8原因：342 + 465 = 807/*** Definition for singly-linked list.* type ListNode struct {* Val int* N...
golang-Binary-Search-Tree
freedbg的博客
01-12 295
package main import ( "fmt" ) func main() { var data = []int{6, 5, 3, 1, 8, 7, 2, 4, 9} // var tree *bst fmt.Println(tree) tree = insert(tree, data[0]) //init tree for _, v := range data {
golang常见数据结构之树
SMILY12138的博客
04-10 643
在上面的代码中，我们首先定义了一个Node类型，它包含一个值和两个子节点。NewNode方法用于创建一个新的节点，Insert方法用于将一个元素插入到树中，Search方法用于搜索树中是否存在某个元素。总之，Golang提供了tree包来实现树的功能。在计算机科学中，树是一种非线性数据结构，它由节点和边组成。在main函数中，我们创建了一个Node对象，并分别将5、13、7、3四个元素插入到树中。tree包提供了丰富的接口和方法，可以轻松地定义和操作树。在Golang中，我们可以使用结构体和指针来实现树。
Golang数据结构实现库：go-libs深度解析
go-libs是针对Go语言的一个库，它提供了一系列的数据结构实现，这些实现不仅遵循Go语言的特性，如并发安全，而且还优化了性能，使得开发者能够更加高效地使用这些数据结构完成编程任务。go-libs项目通过集中管理数据...
Golang优秀开源项目汇总, 10大流行Go语言开源项目, golang 开源项目全集(golang/go/wiki/Projects), GitHub上优秀的Go开源项目...
weixin_34245082的博客
05-08 6341
  Golang优秀开源项目汇总（持续更新。。。）我把这个汇总放在github上了， 后面更新也会在github上更新。 https://github.com/hackstoic/golang-open-source-projects  。 欢迎fork， star ， watch， 提issue。    资料参考来源：http://studygolang.com/projects 监控...
超详细面试准备（10分钟打遍所有初级后端开发面试）
weixin_44540766的博客
02-23 4938
面试知识汇总 如何介绍项目： https://www.sohu.com/a/259724527_775404 自我介绍：https://www.jianshu.com/p/008fc86a1f28 4W字的后端面试知识点总结： https://www.cnblogs.com/aobing/p/12849591.html 后端技术框架： https://www.cnblogs.com/loren-Yang/p/11073536.html 数据结构 Java HashMap原理： https://yikun.g
用GoLang编写的Tree打印机模块-Golang开发
05-26
GoTree简单的Go模块，用于在终端中打印树结构。 Linux的Tree命令为它树立了榜样GoTree的目标是成为一个简单的工具，它提供了一种愚蠢的易于使用和快速的方式来打印递归GoTree Simple Go模块，以在终端中打印树结构。 Linux的Tree命令为它树立了榜样GoTree的目标是成为一个简单的工具，它提供了一种愚蠢的易于使用和快速的方式来打印递归结构。 项目状态GoTree处于测试阶段。 欢迎拉取请求功能非常简单且快速的代码直观的名称易于扩展仅使用本机libsupidly易于使用安装Go Get $ go github.com/disiqueira/gotree用法简单创建
Go-Golang一些基础数据结构的封装比如treebitmap等
08-14
Golang一些基础数据结构的封装比如tree，bitmap等
godirwalk：Golang的快速目录遍历
02-06
godirwalk godirwalk是用于遍历文件系统上的目录树的库。 简而言之，为什么要使用这个库？ 它比filepath.Walk快。 在Windows上，它比filepath.Walk更正确。 它比filepath.Walk更易于使用。 它比filepath.Walk更灵活。 使用范例 在examples/子目录中提供了其他示例。 该库将通过调用特定于OS的路径分隔符的第一个参数filepath.Clean来规范提供的顶级目录名称。 但是，在调用提供的回调函数时，它始终提供使用正确的os-specific路径分隔符创建的路径名。 dirname := "some/
golang ----------- 平衡二叉树-AVL树
田园园野的博客
05-14 1948
平衡二叉树的旋转：有4类，每类中又有两类1、右旋转：当插入的结点为失衡点的左孩子的左孩子，如下图所示，A，B是一种情况，虚线部分表示不存在。这两种情况都是右旋转，代码一样2、左旋转：当插入的结点为失衡点的右孩子的右孩子，如下图所示，A，B是一种情况，虚线部分表示不存在。这两种情况都是右旋转，代码一样3、先右旋转，再左旋转：当插入的结点为失衡点的右孩子的子孩子（左右孩子都行），如下图所示，A，B是一...
golang实现AVL树算法 【AVL树】【算法】【golang】
LYR 的博客
01-19 555
golang avl树算法 package main import ( "fmt" ) var nodeCnt int type Node struct { val int left, right *Node h int } func max(i, j int) int { if i > j { return i } return j } func min(i, j int) int { if i < j { return i
【算法】golang实现Linux的Tree命令（简易版）
wxs0607
10-14 358
通过递归实现打印当前或指定路径下文件的层级结构，暂未实现层级限制选项
avl树 golang实现
Riak, Spark, Golang, Erlang, 云存储, 云计算, 数据挖掘
08-25 3196
package main import ( "fmt" ) type DataType int type Node AVLTreeNode type AVLTree *AVLTreeNode type AVLTreeNode struct { key   DataType high  int left  *AVLTreeNode right *AVLT
golang实现AVL树
skh2015java的博客
02-06 1161
AVL树是带有平衡条件的二叉查找树 特点：AVL树中每个节点的左子树和右子树的高度最多差1   旋转：由于插入操作可能会破坏AVL树的平衡特性，故在插入完成之前通过对树进行简单修正来恢复平衡 示例代码如下： package main import ( "fmt" ) type avlTreeNode struct { key int high int
数据结构与算法 — 树的常见操作（Golang）_golang 树结构
最新发布
2401_82645688的博客
04-14 921
树（tree）是n（n≥0)个节点的有限集。当n=0时，称为空树。在任意一个非空树中，有如下特点：1. 有且仅有一个特定的称为根的节点。2. 当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。树的最大层级数，被称为书的高度或深度。
elevengo: Golang实现的115云存储API包装器
资源摘要信息:"elevengo是一个使用Golang语言编写的API包装器，它提供了与115云存储服务（115 Cloud Storage Service）进行交互的接口。开发者可以通过这个包装器方便地在自己的程序中集成115云存储服务的功能，例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值