Go语言数据结构-二叉树

已于 2022-11-04 11:59:33 修改
阅读量949 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Golang 数据结构和算法 文章标签： 数据结构 golang 二叉树
于 2022-10-27 00:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jeremy_ke/article/details/127543869
本文主要介绍了二叉树这一数据结构，用Golang语言实现。阐述了二叉树的定义、特点和基本结构，详细讲解了前序、中序、后序和宽度优先遍历的思路及代码。还介绍了搜索、满、完全和平衡二叉树的定义、性质及判断方法，并给出代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

定义

二叉树是一种数据结构，它是由 n(n≥1) 个有限节点组成一个具有层次关系的集合。
根节点：最上面的节点；叶子节点：左右子节点都为nil的节点。
在这里插入图片描述

特点

  • 每个节点有零个或两个子节点；
  • 没有父节点的节点称为根节点；
  • 每一个非根节点有且只有一个父节点；
  • 除了根节点外，每个子节点可以分为多个不相交的子树

基本结构

type Node struct {
	Value int
	Left  *Node
	Right *Node
}

遍历

前序遍历

对每颗子树，均遵循根节点–>左节点–>右节点

递归前序
func preShowTree(head *Node) {
	if head == nil {
		return
	}
	fmt.Println(head.V)//第一次来到节点的时候打印
	showTree(head.Left)
	showTree(head.Right)
}
非递归前序(深度优先遍历)

思路：

  1. 声明一个栈
  2. 从栈中弹出一个节点cur
  3. 打印（处理）cur
  4. 先右后左（如果有），把该节点的子节点压入栈中
  5. 循环执行1->2->3

代码实现：

package main

import (
	"errors"
	"fmt"
)

type Node struct {
	Value int
	Left  *Node
	Right *Node
}

type Stack struct {
	MaxTop int      //栈最大可以存放的数的个数
	Top    int      //表示栈顶的索引id，初始值为-1，最大值为MaxTop-1
	Arr    [7]*Node //数组模拟栈
}

func (s *Stack) Push(pushNode *Node) error {
	if s.Top == s.MaxTop-1 {
		return errors.New("栈满了")
	}

	s.Top++
	s.Arr[s.Top] = pushNode

	return nil
}

func (s *Stack) Pop() (popNode *Node, err error) {
	if s.Top == -1 {
		return nil, errors.New("空栈")
	}
	popNode = s.Arr[s.Top]
	s.Arr[s.Top] = nil
	s.Top--
	return popNode, nil
}

func (s *Stack) List() {
	if s.Top == -1 {
		fmt.Println("空栈")
	}
	for i := 0; i < s.Top+1; i++ {
		fmt.Printf("Arr[%v]=%v\n", i, s.Arr[i])
	}
}

func main() {
	root := &Node{Value: 1}
	left := &Node{Value: 3}
	right := &Node{Value: 4}
	root.Left = left
	root.Right = right
	left1 := &Node{Value: 5}
	right1 := &Node{Value: 6}
	left2 := &Node{Value: 7}
	right2 := &Node{Value: 8}
	left.Left = left1
	left.Right = right1
	right.Left = left2
	right.Right = right2
	showTree(root)
}

func preShowTree(head *Node) {
	if head != nil {
		nodeStack := &Stack{MaxTop: 7, Top: -1}
		nodeStack.Push(head)
		for nodeStack.Top < nodeStack.MaxTop-1 && nodeStack.Top > -1 {
			tmpNode, _ := nodeStack.Pop()
			if tmpNode != nil {
				fmt.Println(tmpNode.Value)
			}
			if tmpNode.Right != nil {
				nodeStack.Push(tmpNode.Right)
			}
			if tmpNode.Left != nil {
				nodeStack.Push(tmpNode.Left)
			}
		}
	}

}

中序遍历

中序:对每颗子树，均遵循左节点–>根节点–>右节点

递归中序
func midShowTree(head *Node) {
	if head == nil {
		return
	}
	showTree(head.Left)
    fmt.Println(head.V)//第二次来到节点的时候打印
	showTree(head.Right)
}
非递归中序

思路：

  1. 申请1个栈
  2. 把每颗子树的整树所有左节点入栈
  3. 依次弹出的过程中，打印该节点，且对该节点的右节点，循环1，2,
  4. 循环执行1->2->3
  5. 打印收集栈中数据

代码实现：

func midShowTree(head *Node) {
	if head != nil {
		nodeStack := &Stack{MaxTop: 7, Top: -1}
		for !nodeStack.IsEmpty() || head != nil {
			if head != nil { //所有左节点压入栈
				nodeStack.Push(head)
				head = head.Left
			} else { //弹出栈的数据，打印节点，且对右子节点循环if的操作
				popNode, _ := nodeStack.Pop()
				fmt.Println(popNode.Value)
				head = popNode.Right
			}
		}
	}
}

后序遍历

后序:对每颗子树，均遵循左节点–>右节点–>根节点

递归后序
func afterShowTree(head *Node) {
	if head == nil {
		return
	}
	showTree(head.Left)
	showTree(head.Right)
    fmt.Println(head.V)//第三次来到节点的时候打印
}
非递归后序

思路：

  1. 申请两个栈（普通栈和收集栈）
  2. 从普通栈中弹出一个节点cur
  3. 把该节点压入收集栈中
  4. 先左后右（如果有），把该节点的子节点压入普通栈中
  5. 循环执行1->2->3
  6. 打印收集栈中数据

代码实现：

func afterShowTree(head *Node) {
	if head != nil {
		nodeStack := &Stack{MaxTop: 7, Top: -1}
		showStack := &Stack{MaxTop: 7, Top: -1}
		nodeStack.Push(head)
		for !nodeStack.IsEmpty() {
			popNode, _ := nodeStack.Pop()
			showStack.Push(popNode) //当前节点压入收集栈
			//左子节点压入普通栈
			if popNode.Left != nil {
				nodeStack.Push(popNode.Left)
			}
			//右子节点压入栈
			if popNode.Right != nil {
				nodeStack.Push(popNode.Right)
			}
		}
		//便利收集栈数据
		showStack.List()
	}
}

宽度优先遍历

思路：

  1. 申请一个队列
  2. 把头结点加入队列
  3. 从队列中弹出一个节点cur，并打印
  4. 先左后右（如果有），把该节点的子节点加入队列
  5. 循环执行2->3

代码实现：

type Queue struct {
	buff    []*Node //队列的的数据存储在数组上
	maxsize int     //队列最大容量
	front   int     //队列头索引，不包括自己（队列头索引值-1）
	rear    int     //队列尾索引
}

//
// Push
// @Description: 压入队列
// @Author: maxwell.ke
// @time 2022-10-25 22:58:58
// @receiver q
// @param n
// @return error
//
func (q *Queue) Push(pushNode *Node) error {
	if q.rear == q.maxsize-1 {
		if q.front == -1 { //头尾都到头了
			return fmt.Errorf("队列已满，PUSH失败")
		} else { ////尾都到头了，头有空，则重置front
			q.front = -1
			q.rear = len(q.buff) - 1
		}
	}
	q.rear++
	q.buff = append(q.buff, pushNode)
	return nil
}

//
// Pop
// @Description: 出队列
// @Author: maxwell.ke
// @time 2022-10-25 23:14:20
// @receiver q
// @return n
// @return err
//
func (q *Queue) Pop() (popNode *Node, err error) {
	if len(q.buff) == 0 {
		return nil, fmt.Errorf("空队列,POP失败")
	}
	popNode = q.buff[0]
	q.buff = q.buff[1:]
	q.front++
	return popNode, nil
}

//
// List
// @Description: 队列遍历
// @Author: maxwell.ke
// @time 2022-10-25 23:13:10
// @receiver q
// @return error
//
func (q *Queue) List() error {
	if len(q.buff) == 0 {
		return fmt.Errorf("空队列")
	}
	for i := 0; i < q.maxsize; i++ {
		if i > q.front && i <= q.rear {
			fmt.Println(q.buff[i-q.front-1].Value)
		} else {
			fmt.Println("nil")
		}
	}
	fmt.Println()
	return nil
}

func wideShowTree(head *Node) {
	nodeQueue := &Queue{buff: make([]*Node, 0, 7), maxsize: 7, front: -1, rear: -1}
	nodeQueue.Push(head)
	for len(nodeQueue.buff) < nodeQueue.maxsize && len(nodeQueue.buff) > 0 {
		cur, _ := nodeQueue.Pop()
		fmt.Println(cur.Value)
		if cur.Left != nil {
			nodeQueue.Push(cur.Left)
		}
		if cur.Right != nil {
			nodeQueue.Push(cur.Right)
		}
	}
}

特殊二叉树

搜索二叉树

定义

每一个子树，左节点比根节点小，右节点比根节点大的二叉树，二叉树的节点无重复值。

判断方法

中序（递归中序或者非递归中序均可）遍历二叉树，如果是升序的即为搜索二叉树。

代码实现（递归中序的方法）：

func isBST(head *Node) bool {
	if head == nil {
		return true
	}
	leftBST := isBST(head.Left)
	if !leftBST {
		return false
	}
	//打印事件改为了比较事件
	if head.Value <= preValue {
		return false
	} else {
		preValue = head.Value
	}

	rightBST := isBST(head.Right)
	return rightBST
}

满二叉树

定义

如果二叉树中除了叶子结点，每个结点的度都为2，则此二叉树称为满二叉树。

性质
  1. 满二叉树中第 i 层的节点数为 2^i - 1 个。
  2. 深度为k的满二叉树必有 2k-1 个节点 ，叶子数为 2k-1。
  3. 满二叉树中不存在度为 1 的节点，每一个分支点中都两棵深度相同的子树，且叶子节点都在最底层。
  4. 具有 n 个节点的满二叉树的深度为 log2(n+1)。
判断方法

方法一：根据性质1来判断：

  1. 先求出树的层数i，再统计节点数k
  2. 如果k = 2^i -1，则为满二叉树

方法二：判断左子树为满二叉树且右子树为满二叉树

代码实现：

func isFBT(head *Node) bool {
	if head == nil {
		return true
	}
	leftFBT := isFBT(head.Left)
	if !leftFBT {
		return false
	}
	if (head.Left != nil && head.Right == nil) || (head.Left == nil && head.Right != nil) {
		return false
	}
	rightFBT := isFBT(head.Right)
	return rightFBT
}

完全二叉树

定义

如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。

判断方法
  1. 按照宽度优先遍历
  2. 任意一个节点有右子节点无左子节点，则为非完全二叉树
  3. 在条件1不违规的情况下，如果遇到左右子节点不齐全的情况下，后续节点皆为叶子节点，如果后续存在非叶子节点，则为非完全二叉树。

代码实现：

func isCBT(head *Node) bool {
	if head == nil {
		return true
	}
	var (
		leaf = false //是否遇到左右子节点不齐全的情况
		l    *Node
		r    *Node
	)
	nodeQueue := &Queue{buff: make([]*Node, 0, 8), maxsize: 8, front: -1, rear: -1}
	nodeQueue.Push(head)
	for len(nodeQueue.buff) < nodeQueue.maxsize && len(nodeQueue.buff) > 0 {
		popNode, _ := nodeQueue.Pop()
		l = popNode.Left
		r = popNode.Right

		//如果遇到了不双全的节点后，又发现当前节点有子节点 或者 有右节点但无左节点
		if (leaf && (l != nil || r != nil)) || (l == nil && r != nil) {
			return false
		}

		if l != nil {
			nodeQueue.Push(l)
		}
		if r != nil {
			nodeQueue.Push(r)
		}
		if l == nil || r == nil { //左右节点不双全，则后续为叶子节点
			leaf = true
		}
	}
	return true
}

平衡二叉树

定义

对于任何一个子树来说，左树高度和右树高度差不超过1

判断方法

A && B && C
A: 左子树为平衡二叉树
B: 右子树为平衡二叉树
C: abs(左高-右高) <= 1
代码实现：

func isALV(head *Node) bool {
	return process(head).IsBalanced
}

type ReturnType struct {
	IsBalanced bool
	Height     int
}

func process(x *Node) *ReturnType {
	if x == nil {
		return &ReturnType{IsBalanced: true, Height: 0}
	}
	leftData := process(x.Left)
	rightData := process(x.Right)
	height := max(leftData.Height, rightData.Height) + 1 //当前节点的高度
	isBalanced := leftData.IsBalanced && rightData.IsBalanced && math.Abs(float64(leftData.Height-rightData.Height)) <= 1
	return &ReturnType{IsBalanced: isBalanced, Height: height}
}

func max(a, b int) int {
	maxNum := a
	if a < b {
		maxNum = b
	}
	return maxNum
}
用go实现二叉树
m15082717021的博客
05-08 927
用go实现二叉树的增删改查和三种遍历
go实现二叉树
实践求真知
06-01 379
一代码 package main import ( "fmt" ) type Hero struct { No int Name string Left *Hero Right *Hero } // 前序遍历：先输 root 结点，然后再输出左子树，然后再输出右子树 func PreOrder(node *Hero) { if node != nil { fmt.Printf("no=%d name=%s\n", node.No, nod.
Go语言-二叉树
Zlwriii的博客
04-11 896
目录 前言 1、前序遍历 2、中序遍历 3、后序遍历 前言 满足以下两个条件的数就是二叉树： 1.本身是有序树； 2.树中包含的各个节点的度不能超过2，即只能是0、1或者2。 1、前序遍历 示例：用递归的方式遍历。（根左右） package main import "fmt" //定义结构体 type Student struct { Name string Age int Score float32 left *Student right *Student
【数据结构 -- 二叉搜索树（BST）】用golang实现二叉搜索树
最新发布
2401_87046050的博客
05-19 895
二叉搜索树的概念、性质及实现方法（golang版）
GO语言实现二叉树
haya的博客
01-19 358
GO语言实现二叉树 二叉树还不了解的可以点击树、二叉树、二叉查找树（二叉搜索树） import( "fmt" "math/rand" "time" ) const ( rangeNum = 100 ) //树结构体 type tree struct{ value interface{} left, right *tree } var arr []in...
go语言实现--二叉树
u010412301的博客
01-17 233
  go语言实现--二叉树    版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.youkuaiyun.com/tuobicui6522/article/details/80502130 二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的...
C语言中文网 Go语言二叉树数据结构的应用 源码
06-04
C语言中文网 Go语言二叉树数据结构的应用 源码。一开始以为“btree”是golang的包呢。后来发现不是。又找以为是“https://github.com/google/btree.git”。发现还不是。这才想起来可能是自己写的包。绕了一圈子。 ...
数据结构-go-algorithm.zip
09-19
在数据结构领域中，算法的设计与分析是核心话题，而使用golang语言实现这些算法则提供了一种高效、现代的编程范式。本压缩包中的内容涵盖了多种基础数据结构以及常见的排序与搜索算法，是学习和研究数据结构与算法的...
Go数据结构-集合、列表、堆栈、地图、树、队列等等
02-22
Go语言，作为一种高效、简洁的编程语言，提供了丰富的内置数据类型，但为了实现更复杂的数据处理，我们经常需要自定义或利用库来构建特定的数据结构。本篇文章将深入探讨Go语言中的集合、列表、堆栈、地图、树和队列...
C语言数据结构二叉树简单应用
08-30
本文主要介绍了C语言数据结构二叉树简单应用的相关知识点，涵盖了二叉树的创建、先中后序递归遍历、统计叶子结点的总数、求树的高度、反转二叉树、输出每个叶子结点到根节点的路径、输出根结点到每个叶子结点的路径...
go语言实现二叉树
crushcoding的博客
09-01 437
//设置节点 type Node struct { Value int Left *Node Right *Node } //设置或者修改的 func (node *Node)SetNodeValue (value int) { node.Value = value } //创建一个node func CreateNode(value int) *Node { return &Node{value,nil,nil} } //在2叉树中找到指定的值的节点 func (node *Nod
go二叉树实现
u011290064的博客
03-20 419
package main import ( "fmt" ) type Node struct { Value int Left, Right *Node } func (node *Node) Print() { fmt.Print(node.Value, " ") } func (node *Node) SetValue(v int) { if...
Go语言实现二叉树（BinaryTree）
xing的博客
10-29 871
go语言实现二叉树（BinaryTree） &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;使用go语言实现了二叉树的一些基本功能，存储节点数据的类型为int。（有什么建议或者不懂的地方可以留言） 实现代
GO中二叉树的实现必知必会
weixin_62421895的博客
08-26 370
如果你是一个开发人员，或多或少对树型结构都有一定的认识，我个人对树型数据结构是又爱又恨。二叉树作为树的一种,是一种重要的数据结构,也是面试官经常考的东西。这篇文章主要分享下关于二叉树相关的知识点，并用go语言实现一个二叉树和对二叉树进行遍历。...
数据结构-二叉树入门Go语言实现
qq_22328011的博客
04-25 796
数据结构-二叉树入门Go语言实现 之前我们一直在谈的是一对一的线性结构，可现实中，还有很多一对多的情况需要处理，所以我们需要研究这种一对多的数据结构——“树”，考虑它的各种特性，来解决我们在编程中碰到的相关问题。 树的定义 树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集 T1 、T2 、……、Tm ，其中每一个集合本身又是一棵树，并且称为根的子树（Su
go 二叉树
王飞的博客
11-05 255
二叉树定义 type Student struct { Name string left* Student right* Student } 如果每个节点有两个指针分别用来指向左子树和右子树，我们把这样的结构叫做二叉树 example01 package main import "fmt" type Student struct { Name s...
二叉树-golang
雨竹的博客
02-17 1235
package main import "fmt" func main() { arr := []int{10, 5, 24, 30, 60, 40, 45, 15, 27, 49, 23, 42, 56, 12, 8, 55, 2, 9} fmt.Println(arr) t := creatTree(arr) preorder(t[0]) fmt.Print...
GO语言实现二叉树基本功能
g2020161853的博客
04-18 403
用go语言和递归算法完成二叉树的遍历、求结点数、求深度等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值