go语言｜数据结构：二叉树（2）广度和深度搜索_数据结构广度和深度怎么导入

于 2024-05-12 23:06:11 发布
阅读量1k 收藏 11
点赞数 17
分类专栏： 程序员 文章标签： go 学习 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84905039/article/details/138771361
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

}
Queue := []*btNode{root}
for len(Queue) > 0 {
	cur := Queue[0]
	Queue = Queue[1:]
	if cur.Lchild != nil {
		Queue = append(Queue, cur.Lchild)
	} else {
		cur.Lchild = &btNode{Data: data}
		return
	}
	if cur.Rchild != nil {
		Queue = append(Queue, cur.Rchild)
	} else {
		cur.Rchild = &btNode{Data: data}
		break
	}
}

}

func (bt *biTree) Levelorder() []interface{} {
var res []interface{}
root := bt.root
if root == nil {
return res
}
Queue := []*btNode{root}
for len(Queue) > 0 {
cur := Queue[0]
Queue = Queue[1:]
res = append(res, cur.Data)
if cur.Lchild != nil {
Queue = append(Queue, cur.Lchild)
}
if cur.Rchild != nil {
Queue = append(Queue, cur.Rchild)
}
}
return res
}

func (bt *biTree) Preorder() []interface{} {
var res []interface{}
cur := bt.root
Stack := []*btNode{}
for cur != nil || len(Stack) > 0 {
for cur != nil {
res = append(res, cur.Data)
Stack = append(Stack, cur)
cur = cur.Lchild
}
if len(Stack) > 0 {
cur = Stack[len(Stack)-1]
Stack = Stack[:len(Stack)-1]
cur = cur.Rchild
}
}
return res
}

func (bt *biTree) Inorder() []interface{} {
var res []interface{}
cur := bt.root
Stack := []*btNode{}
for cur != nil || len(Stack) > 0 {
for cur != nil {
Stack = append(Stack, cur)
cur = cur.Lchild
}
if len(Stack) > 0 {
cur = Stack[len(Stack)-1]
res = append(res, cur.Data)
Stack = Stack[:len(Stack)-1]
cur = cur.Rchild
}
}
return res
}

func (bt *biTree) Postorder() []interface{} {
var res []interface{}
var cur, pre *btNode
Stack := []*btNode{bt.root}
for len(Stack) > 0 {
cur = Stack[len(Stack)-1]
if cur.Lchild == nil && cur.Rchild == nil ||
pre != nil && (pre == cur.Lchild || pre == cur.Rchild) {
res = append(res, cur.Data)
Stack = Stack[:len(Stack)-1]
pre = cur
} else {
if cur.Rchild != nil {
Stack = append(Stack, cur.Rchild)
}
if cur.Lchild != nil {
Stack = append(Stack, cur.Lchild)
}
}
}
return res
}

func main() {

list := []interface{}{1, 2, 3, 4, 5, 6, 7}

tree := &biTree{}
fmt.Println(tree.Preorder())
tree.Append(0)
fmt.Println(tree.Preorder())
tree.Append(1)
fmt.Println(tree.Preorder())

tree = Create(list)
fmt.Println(tree.Preorder())
fmt.Println(tree.Inorder())
fmt.Println(tree.Postorder())

tree.Append("+")
tree.Append("-")
fmt.Println(tree.Inorder())
tree.Append([]interface{}{"A", "B", "C"})
fmt.Println(tree.Preorder())
fmt.Println(tree.Inorder())
fmt.Println(tree.Postorder())

}

/*
[]
[0]
[0 1]
[1 2 4 5 3 6 7]
[4 2 5 1 6 3 7]
[4 5 2 6 7 3 1]
[+ 4 - 2 5 1 6 3 7]
[1 2 4 + - 5 A B 3 6 C 7]
[+ 4 - 2 A 5 B 1 C 6 3 7]
[+ - 4 A B 5 2 C 6 7 3 1]
*/


### 自定义包 biTree


上面的代码中，去掉import "fmt"一行 及 main()函数全部，package main替换成 package biTree，然后另存为 biTree.go。


接下来在DOS窗口用set gopath查看GOPATH变量，我的电脑返回：



> 
> C:\Users\admin>set gopath
> 
> 
> GOPATH=C:\Users\admin\go;d:\GOsrc
> 
> 
> 


在gopath的任一路径下新建一个src文件夹，再在src下新建biTree文件夹，最后把biTree.go存放到此文件夹下，就能导入import使用了。


注意：**自定义包中的函数和方法命名时一定要首字母大写**，否则调用会无法找到。


#### 导入和调用

package main

import (
“biTree” //导入二叉树自定义包 biTree
“fmt”
)

func main() {

list := []interface{}{1, 2, 3, 4, 5, 6, 7}

tree := biTree.Create(list)  //调用自定义包中的函数，需要用“包名称.”作前缀
fmt.Println(tree.Preorder()) //调用方法则不需要前缀，tree就是此包定义的对象
fmt.Println(tree.Inorder())
fmt.Println(tree.Postorder())
fmt.Println(tree.Levelorder())

tree.Append(0)
tree.Append("+")
tree.Append("-")
fmt.Println(tree.Inorder())
tree.Append([]interface{}{"A", "B", "C"})
fmt.Println(tree.Preorder())
fmt.Println(tree.Inorder())
fmt.Println(tree.Postorder())
fmt.Println(tree.Levelorder())

}

/*
[1 2 4 5 3 6 7]
[4 2 5 1 6 3 7]
[4 5 2 6 7 3 1]
[1 2 3 4 5 6 7]
[0 4 + 2 - 5 1 6 3 7]
[1 2 4 0 + 5 - A 3 6 B C 7]
[0 4 + 2 - 5 A 1 B 6 C 3 7]
[0 + 4 - A 5 2 B C 6 7 3 1]
[1 2 3 4 5 6 7 0 + - A B C]
*/


### 广度优先搜索BFS & 深度优先搜索DFS


是连通图等图结构的一种遍历算法原型，而树也可以看作是一种没用环的特殊图结构。


#### 广度优先搜索BFS


Breath First Search，也称宽度优先搜索，缩写BFS。也即先横向再纵向的搜索，BFS使用**队列**来实现。BFS就是上一集中写的层序遍历Levelorder()，层序遍历即广度优先。


![](https://img-blog.csdnimg.cn/c45664b2b0b34a2ca10875ebd99c2e2c.gif)


#### 深度优先搜索DFS


Depth First Search，缩写DFS。也即先纵向再横向的搜索，DFS使用**栈**来实现。DFS就是上一集中写的先序遍历Preorder()，可认为先序遍历即深度优先。


![](https://img-blog.csdnimg.cn/c59197aa8fa247b3a47b0cf4d17719a5.gif)


#### 遍历二叉树全部叶子结点


**递归法：**

func (bt *btNode) leaves() []interface{} {
var res []interface{}
if bt != nil {
if bt.Lchild == nil && bt.Rchild == nil {
res = append(res, bt.Data)
}
res = append(res, bt.Lchild.leaves()…)
res = append(res, bt.Rchild.leaves()…)
}
return res
}


**广度优先BFS：**

func (bt *biTree) LeafNodeBFS() []interface{} {
var res []interface{}
root := bt.root
if root == nil {
return res
}
Queue := []*btNode{root}
for len(Queue) > 0 {
cur := Queue[0]
Queue = Queue[1:]
if cur.Lchild == nil && cur.Rchild == nil {
res = append(res, cur.Data)
}
if cur.Lchild != nil {
Queue = append(Queue, cur.Lchild)
}
if cur.Rchild != nil {
Queue = append(Queue, cur.Rchild)
}
}
return res
}


**深度优先DFS：**

func (bt *biTree) LeafNodeDFS() []interface{} {
var res []interface{}
cur := bt.root
Stack := []*btNode{}
for cur != nil || len(Stack) > 0 {
for cur != nil {
if cur.Lchild == nil && cur.Rchild == nil {
res = append(res, cur.Data)
}
Stack = append(Stack, cur)
cur = cur.Lchild
}
if len(Stack) > 0 {
cur = Stack[len(Stack)-1]
Stack = Stack[:len(Stack)-1]
cur = cur.Rchild
}
}
return res
}




---


### **BFS/DFS题目实例**


#### **实例1：层序遍历二叉树成二维数组**



> 
> **(leetcode102#) Binary Tree Level Order Traversal**
> 
> 
> Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).  
>  For Example:  
>  Given binary tree [3,9,20,null,null,15,7],  
>   3  
>   / \  
>  9 20  
>      / \  
>    15 7
> 
> 
> return its level order traversal as:  
>  [  
>  [3],  
>  [9,20],  
>  [15,7]  
>  ]
> 
> 
> 
> **(leetcode107#) Binary Tree Level Order Traversal II**
> 
> 
> 102题的结果倒序，返回[[3],[9,20],[15,7]]，代码略。
> 
> 
> 


遍历代码如下，把它写进biTree.go备用：

func (bt *biTree) BForder2D() [][]interface{} {
var res [][]interface{}
root := bt.root
if root == nil {
return res
}
Queue := []*btNode{root}
for len(Queue) > 0 {
Nodes := []interface{}{}
Levels := len(Queue)
for Levels > 0 {
cur := Queue[0]
Queue = Queue[1:]
Nodes = append(Nodes, cur.Data)
Levels–
if cur.Lchild != nil {
Queue = append(Queue, cur.Lchild)
}
if cur.Rchild != nil {
Queue = append(Queue, cur.Rchild)
}
}
res = append(res, Nodes)
}
return res
}


遍历过程如以下动图：


![](https://img-blog.csdnimg.cn/4d734484bee54f8a8220a2b98aa4781c.gif)


测试代码：

package main

import (
“biTree” //导入二叉树自定义包 biTree
“fmt”
)

func main() {

list1 := []interface{}{1, 2, 4, 5, 6}
list2 := []interface{}{3, 9, 20, 15, 7}

tree := biTree.Create(list1)
fmt.Println(tree.BForder2D())

tree = biTree.Create(list2)
fmt.Println(tree.BForder2D())

}

/*
[[1] [2 4] [5 6]]
[[3] [9 20] [15 7]]
*/


注意：代码遍历方法是正确的，但是题目给定的数组是 [3,9,20,null,null,15,7]，而Create()函数按层再从左到右添加结点的，它创建的是一个完全二叉树。需要增加对数据域的类型判断，空值在Go语言中用**nil**表示，在遍历数组时碰到**nil**值，则跳过创建此结点，这样就可以创建一个非完全二叉树。另外存在没法创建的可能，比如： {1, nil, nil, 2, 3}，要么忽略要么抛出错误。


改进后的创建代码Build()函数，放进biTree.go，以备调用。

func Build(data interface{}) *biTree {
var list []interface{}
if data == nil {
return &biTree{}
}
switch data.(type) {
case []interface{}:
list = append(list, data.([]interface{})…)
default:
list = append(list, data)
}
if len(list) == 0 {
return &biTree{}
}

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ace{}:
list = append(list, data.([]interface{})…)
default:
list = append(list, data)
}
if len(list) == 0 {
return &biTree{}
}

[外链图片转存中…(img-tT1sUBAw-1715526348621)]
[外链图片转存中…(img-elgi6u8J-1715526348621)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84905039
关注
  • 17
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go-Golang算法和数据结构
08-14
在编程领域，算法和数据结构是核心技术之一，对于任何编程语言来说都至关重要，Go语言（Golang）也不例外。Go语言以其简洁的语法、高效的性能以及内置的并发支持，成为了很多开发者首选的系统级编程语言。本资料包...
使用go语言实现数据结构与算法
最新发布
06-17
2. 搜索算法：线性搜索、二分搜索、深度优先搜索（DFS）和广度优先搜索（BFS）。 3. 动态规划：解决多阶段决策过程最优化问题，例如斐波那契数列、背包问题等。 4. 分治策略：将大问题分解为小问题，如快速排序、...
基础-深度优先搜索（DFS）
Ice_teapoy的博客
02-19 2008
1 深度优先搜索（DFS） 1.1 定义 先说什么是搜索。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。在忽略效率的情况下，没有什么是搜索解决不了的（？ 深度优先搜索（DFS）是基于递归的搜索。 想象你在走迷宫： 1、 这个方向有路可走，我没走过 2、 往这个方向前进 3、 是死胡同（到达了已经走过的地方），往回走，回到上一个路口 4、 重复第一步，直到找着出口 通过这种方式，只要地点的数量是有限的，你就一定可以在有限的时间找到迷宫的出口（或者确
万能的搜索——深度搜索和广度搜索
明里灰的博客
12-04 6330
搜索分为深度优先搜索（dfs）和广度优先搜索（bfs）先学习深度优先搜索。深度搜素是往深度方向进行搜索的，先选一条路走到底，再选另一条路，用于二维数组和二维字符数组。【题目描述】有一天，小哈一个人去玩迷宫。但是方向感很不好的小哈很快就迷路了。小哼得知后便要去解救无助的小哈。小哼当然是有备而来，已经弄清楚了迷宫的地图，现在小哼要以最快的速度去解救小哈。问题就此开始了…… 迷宫由n行m列的单元格组成（n和m都小于等于50），每个单元格要么是空地（用0表示），要么是障碍物（用1表示）。你的任务是帮助小哼找到一条从
常用算法：深度优先搜索（Depth First Search ）
羊羊的博客
12-23 3882
       最近事少，代码也写的少，当然工作这么些年写过的代码也能绕xx四五圈啊四五圈，现在则思考除了纯粹写代码之外的事情，比如总结一些常用的通用的算法，学习一下遗忘很久的数学，思考下今后的发展，比如是在哪个桥洞下讨饭什么的。        实际上呢，很多数学和算法，我们的开发生涯中都是使用过的，但是记忆力这个东西是不可靠的，我小时候看过一本叫XYZ记忆法和记忆宫殿的书，里面讲的人的“永久记忆...
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 8399
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
深度搜索(DFS)，一种用于遍历和搜索的算法
qq_41842588的博客
07-07 6942
先上百度对深度搜索的定义： 如果上边的定义没有理解，那么可以这样认为：深度搜索就是一种试探性的算法，例如你在一个十字路口想要去到某地，但是你又不认识具体的路(并且你不善言辞，万事不求人)，那么你只能先选一个方向走，一直走下去直到发现此路不通，这时你又会掉头回到起始的十字路口，在往另一个方向试试，直到找到你要去的那个地方。这个不断试探的方式，套用的是递归的基本思想...
Go-go-algorithms-使用golang实现不同的算法和数据结构
08-14
本项目"Go-go-algorithms-使用golang实现不同的算法和数据结构"旨在深入探讨如何在Go语言中实现各种经典的数据结构和算法，从而帮助开发者提升编程技能和解决问题的能力。 首先，我们来看看数据结构。数据结构是指...
利用 Go 语言实现常用的数据结构与算法。.zip
06-17
通过学习和实践这个资料包中的内容，你将能够熟练地在 Go 语言中实现和应用各种数据结构和算法，这对于提升编程技能和解决实际问题能力至关重要。同时，理解这些基础概念也能为学习其他编程语言打下坚实的基础。
深度优先搜索详解
panpanpan17452的博客
10-10 5657
深度优先搜索详解
【图】图的深度搜索和广度搜索
weixin_42596089的博客
05-24 3557
具体来说，BFS会先访问起始顶点，然后依次访问与起始顶点直接相邻的所有顶点，接着访问与这些顶点直接相邻的未被访问过的顶点，以此类推，直到找到目标顶点或者遍历完整张图。图的深度优先遍历（Depth First Search，DFS）是一种遍历图的算法，其基本思想是从起始顶点开始，不断访问邻接顶点，直到无法继续访问为止，然后回溯到之前的顶点，继续访问其未被访问过的邻接顶点。在实现过程中，可以使用栈来存储待访问的顶点，每次访问一个顶点时，将其所有未被访问过的邻接顶点压入栈中，然后从栈中弹出一个顶点进行访问。
【Python搜索算法】深度优先搜索（DFS）算法原理详解与应用，示例+代码
热门推荐
qq_35831906的博客
10-16 1万+
深度优先搜索（DFS）是一种重要的图遍历算法，用于探索图中的节点和边。本节介绍DFS算法原理和DFS算法应用案例：解决路径查找问题，解决图的连通性问题：查找下图中的连通组件，拓扑排序，在树结构中进行深度遍历
深度优先搜索（DFS、深搜）和广度优先搜索（BFS、广搜）
ZJQ的博客
08-16 3787
本节介绍了两种遍历图的方式：深度优先搜索算法和广度优先搜索算法。深度优先搜索算法的实现运用的主要是回溯法，类似于树的先序遍历算法。广度优先搜索算法借助队列的先进先出的特点，类似于树的层次遍历。
深度搜索和广度搜索是什么？代码怎么实现？
qq_53830608的博客
02-07 1624
对下左图进行如右图的深度搜索：从顶点A开始遍历，接着遍历A的第一个邻接顶点继续从B开始遍历B的第一个邻接顶点C，接着从C始遍历C的第一个邻接顶点D...直到遍历到F，F的第一个临界顶点已经被遍历，则遍历F的下一个邻接顶点G，接着从G的第一个邻接顶点遍历。对下左图进行广度搜索： 从顶点A开始遍历，接着遍历A的第一个邻接顶点B继续从B开始遍历B的第一个邻接顶点C，接着从C开始遍历C的第一个邻接顶点D.直到遍历到F，F的第一个临界顶点已经被遍历，则遍历F的下一个邻接顶点G，接着从G的第一个邻接顶点遍历。
【算法】深度搜索(DFS) 和 广度搜索(BFS)
指错||纠正||建议||水评+点赞&&评论&&关注&&转发，在这里你大概率会有所收获
07-29 3275
深度搜索(DFS) 和 广度搜索(BFS)
深度优先搜索（DFS）和广度优先搜索（BFS）
追风者
02-16 3268
自己对于这块地方还是有点忘，而且后面要经常用到搜索，所以整理一下。 搜索真的是个很神奇的东西，通过代码的变化就能解决许许多多种的实际问题。 一、深度优先搜索(Depth First Search)，重在追求”专一”吧!一条道走到黑， 主要是递归思想。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的 邻接点出发深度优先搜索...
深度搜索(DFS)和广度搜索(BFS)
qq_42712351的博客
07-18 1万+
深度搜索(DFS) 一、搜索方法：  沿出发顶点的第一条路径尽量深入，遍历路径上所有顶点；然后退回到该顶点，搜索其它路径，直到以该顶点为始点的所有路径的顶点都被访问，深度搜索算法是递归算法，因为对于没一个节点来说，执行的是同样的操作。  简单来说，深度搜素算法就是一条道走到黑，走不动了再回溯回去，选择其他路径，举个例子，对于下面的图，假设从1开始遍历： （1）第一步，访问结点1并标记 （...
深度搜索
qq_44238714的博客
04-08 1619
深度搜索： 深度搜索的方法： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。　当然，当人们刚刚掌握深度优先搜索的时候常常用它来走迷宫. 例题：迷宫问题 有一天，傻子A一个人去迷宫玩，但是他的方向感并不是很好，所...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值