Go数据结构----树的操作

永远不要低估自己的能力

于 2023-05-18 17:46:45 发布

阅读量952

点赞数

文章标签：数据结构 golang 链表

本文链接：https://blog.csdn.net/zhangzhongyanting/article/details/130752257

版权

文章介绍了树作为一种基础数据结构，特别是二叉树的概念，包括满二叉树和完全二叉树的定义。二叉树的数学特性，如高度和节点数量的关系，以及四种遍历方式：先序、中序、后序和层次遍历。其中层次遍历使用了广度优先搜索，通过队列实现。文章还提供了Go语言实现的遍历函数示例。

摘要由CSDN通过智能技术生成

七、树

树是一种比较高级的基础数据结构，由n 个有限节点组成的具有层次关系的集合。

树的定义：

有节点间的层次关系，分为父节点和子节点。
有唯一一个根节点，该根节点没有父节点。
除了根节点，每个节点有且只有一个父节点。
每一个节点本身以及它的后代也是一棵树，是一个递归的结构。
没有后代的节点称为叶子节点，没有节点的树称为空树。

**二叉树：**每个节点最多只有两个儿子节点的树

满二叉树：叶子节点与叶子节点之间的高度差为0的二叉树，即整棵树是满的，树呈满三角形结构。在国外的定义，非叶子节点儿子都是满的树就是满二叉树。我们以国内为准。

**完全二叉树：**完全二叉树是由满二叉树而引出来的，设二叉树的深度为 k，除第 k 层外，其他各层的节点数都达到最大值，且第 k 层所有的节点都连续集中在最左边。

树根据儿子节点的多寡，有二叉树，三叉树，四叉树等，我们这里主要介绍二叉树。

一、二叉树的数学特征

高度为 h≥0 的二叉树至少有 h+1 个结点，比如最不平衡的二叉树就是退化的线性链表结构，所有的节点都只有左儿子节点，或者所有的节点都只有右儿子节点。
高度为 h≥0 的二叉树至多有 2^h+1 个节点，比如这棵树是满二叉树。
含有 n≥1 个结点的二叉树的高度至多为 n-1，由 1 退化的线性链表可以反推。
含有 n≥1 个结点的二叉树的高度至少为 logn，由 2 满二叉树可以反推。
在二叉树的第 i 层，至多有 2^(i-1) 个节点，比如该层是满的。

二、二叉树的实现

二叉树可以使用链表来实现。如下：

// TreeNode  二叉树
type TreeNode struct {
	Data  string    //节点用来存放数据
	Left  *TreeNode //左子树
	Right *TreeNode //右子树
}

当然，数组也可以用来表示二叉树，一般用来表示完全二叉树。

对于一棵有 n 个节点的完全二叉树，从上到下，从左到右进行序号编号，对于任一个节点，编号 i=0 表示树根节点，编号 i 的节点的左右儿子节点编号分别为：2i+1,2i+2，父亲节点编号为：i/2，整除操作去掉小数。

如图是一棵完全二叉树，数组的表示：

我们一般使用二叉树来实现查找的功能，所以树节点结构体里存放数据的 Data 字段。

三、遍历二叉树

构建一棵树后，我们希望遍历它，有四种遍历方法：

先序遍历：先访问根节点，再访问左子树，最后访问右子树。（根左右）
后序遍历：先访问左子树，再访问右子树，最后访问根节点。（左右根）
中序遍历：先访问左子树，再访问根节点，最后访问右子树。（左根右）
层次遍历：每一层从左到右访问每一个节点。

先序，后序和中序遍历较简单，代码如下：

//PreOrder 线序遍历 采用了递归的方法进行实现
func PreOrder(tree *TreeNode)  {
	if tree != nil {
		return
	}
	//先打印根节点
	fmt.Print(tree.Data," ")
	//然后再打印左子树
	PreOrder(tree.Left)
	PreOrder(tree.Right)
}
//中序遍历
func MidOrder(tree *TreeNode)  {
	if tree != nil {
		return
	}
	//先打印左子树
	MidOrder(tree.Left)
	//再打印根节点
	fmt.Print(tree.Data," ")
	//再打印右子树
	MidOrder(tree.Right)
}
//后续遍历
func PostOrder(tree *TreeNode)  {
	if tree != nil {
		return
	}
	//先打印左子树
	PostOrder(tree.Left)
	//再打印右子树
	PostOrder(tree.Right)
	//再进行我们的根节点打印
	fmt.Print(tree.Data," ")
}

然后进行验证，看如下树结构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hVBwjM76-1684403134616)(C:\Users\27198\AppData\Roaming\Typora\typora-user-images\image-20230518171731268.png)]

进行对应的实现

层次遍历较复杂，用到一种名叫广度遍历的方法，需要使用辅助的先进先出的队列。

先将树的根节点放入队列。
从队列里面 remove 出节点，先打印节点值，如果该节点有左子树节点，左子树入栈，如果有右子树节点，右子树入栈。
重复2，直到队列里面没有元素。

核心如下所示：

func LayerOrder(treeNode *TreeNode) {
    if treeNode == nil {
        return
    }
    // 新建队列
    queue := new(LinkQueue)
    // 根节点先入队
    queue.Add(treeNode)
    for queue.size > 0 {
        // 不断出队列
        element := queue.Remove()
        // 先打印节点值
        fmt.Print(element.Data, " ")
        // 左子树非空，入队列
        if element.Left != nil {
            queue.Add(element.Left)
        }
        // 右子树非空，入队列
        if element.Right != nil {
            queue.Add(element.Right)
        }
    }
}

完整案例如下所示：

package main

import (
	"fmt"
	"sync"
)

// 二叉树
type TreeNode struct {
	Data  string    // 节点用来存放数据
	Left  *TreeNode // 左子树
	Right *TreeNode // 右字树
}

func LayerOrder(treeNode *TreeNode) {
	if treeNode == nil {
		return
	}
	//新建队列
	queue := new(LinkQueue)

	//然后根节点优先入队 Add队列里的知识
	queue.Add(treeNode)
	for queue.size > 0 {
		//不断出队
		element := queue.Remove()
		//先打印节点值
		fmt.Print(element.Data, " ")
		// 左子树非空，入队列
		if element.Left != nil {
			queue.Add(element.Left)
		}
		// 右子树非空，入队列
		if element.Right != nil {
			queue.Add(element.Right)
		}
	}
}

// LinkNode 链表节点
type LinkNode struct {
	Next  *LinkNode
	Value *TreeNode
}

type LinkQueue struct {
	root *LinkNode  //链表起点
	size int        //队列的元素数量
	lock sync.Mutex //为了实现并发安全的锁

}

// 入队
func (queue *LinkQueue) Add(v *TreeNode) {
	queue.lock.Lock()
	defer queue.lock.Unlock()
	// 如果栈顶为空，那么增加节点
	if queue.root == nil {
		queue.root = new(LinkNode)
		queue.root.Value = v
	} else {
		// 否则新元素插入链表的末尾
		// 新节点
		newNode := new(LinkNode)
		newNode.Value = v
		// 一直遍历到链表尾部
		nowNode := queue.root
		for nowNode.Next != nil {
			nowNode = nowNode.Next
		}
		// 新节点放在链表尾部
		nowNode.Next = newNode
	}
	// 队中元素数量+1
	queue.size = queue.size + 1
}

// 出队
func (queue *LinkQueue) Remove() *TreeNode {
	queue.lock.Lock()
	defer queue.lock.Unlock()
	// 队中元素已空
	if queue.size == 0 {
		panic("over limit")
	}
	// 顶部元素要出队
	topNode := queue.root
	v := topNode.Value
	// 将顶部元素的后继链接链上
	queue.root = topNode.Next
	// 队中元素数量-1
	queue.size = queue.size - 1
	return v
}

// 队列中元素数量
func (queue *LinkQueue) Size() int {
	return queue.size
}

func main() {
	t := &TreeNode{Data: "A"}
	t.Left = &TreeNode{Data: "B"}
	t.Right = &TreeNode{Data: "C"}
	t.Left.Left = &TreeNode{Data: "D"}
	t.Left.Right = &TreeNode{Data: "E"}
	t.Right.Left = &TreeNode{Data: "F"}
	fmt.Println("\n层次排序")
	LayerOrder(t)
}