Golang(五十四)[树-二叉树]

最新推荐文章于 2023-07-11 16:38:34 发布
最新推荐文章于 2023-07-11 16:38:34 发布
阅读量317 收藏
点赞数
分类专栏： Golang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42366378/article/details/106217052
版权

Golang-树-二叉树

1.初始化

mkdir -p binaryTree
cd binaryTree
go mod init binaryTree
touch binaryTree.go
vim binaryTree.go

2.定义二叉树结点结构体

// 定义二叉树结点结构体
type BinaryTreeNode struct {
	// 数据域
	Data interface{}
	// 左子结点
	Lchild *BinaryTreeNode
	// 右子结点
	Rchild *BinaryTreeNode
}

3.根据图创建二叉树

在这里插入图片描述

// 根据图创建二叉树
func (node *BinaryTreeNode) CreateBinaryTree() {
	if node == nil {
		return
	}
	node1 := &BinaryTreeNode{1, nil, nil}
	node2 := &BinaryTreeNode{2, nil, nil}
	node3 := &BinaryTreeNode{3, nil, nil}
	node4 := &BinaryTreeNode{4, nil, nil}
	node5 := &BinaryTreeNode{5, nil, nil}
	node6 := &BinaryTreeNode{6, nil, nil}
	node7 := &BinaryTreeNode{7, nil, nil}

	node.Data = 0
	node.Lchild = node1

	node1.Lchild = node3
	node1.Rchild = node4
	node3.Lchild = node7

	node.Rchild = node2
	node2.Lchild = node5
	node2.Rchild = node6
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println(tree) // &{0 0xc0000044c0 0xc0000044e0} // 数据，左子节点，右子节点
}

4.打印二叉树

二叉树的遍历的前提都是【先左右后】

先序、中序、后序遍历是取决于根、如果根在前就是先序DLR（Data，Lchild，Rchild），根在中间即中序LDR（Lchild，Data，Rchild）、根在后就是后序LRD（Lchild，Rchild，Data）

1.先序遍历DLR

根、左子树、右子树

// 打印二叉树---先序遍历DLR：先根、再左、再右
func (node *BinaryTreeNode) PreOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 根（Data）
	fmt.Print(node.Data, " ")
	// 左子树（Lchild）递归调用
	node.Lchild.PreOrderPrint()
	// 右子树（Rchild）递归调用
	node.Rchild.PreOrderPrint()
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("先序遍历结果：")
	tree.PreOrderPrint()
}

0 1 3 7 4 2 5 6

2.中序遍历LDR

左子树、根、右子树

// 打印二叉树---中序遍历LDR：先左、再根、再右
func (node *BinaryTreeNode) MidOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.MidOrderPrint()
	// 根（Data）
	fmt.Print(node.Data, " ")
	// 右子树（Rchild）递归调用
	node.Rchild.MidOrderPrint()
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("中序遍历结果：")
	tree.MidOrderPrint()
}

7 3 1 4 0 5 2 6

3.后序遍历LRD

左子树、右子树 、根

// 打印二叉树---后序遍历LRD：先左、再右、再根
func (node *BinaryTreeNode) PostOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.PostOrderPrint()

	// 右子树（Rchild）递归调用
	node.Rchild.PostOrderPrint()
	// 根（Data）
	fmt.Print(node.Data, " ")
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("后序遍历结果：")
	tree.PostOrderPrint()
}

7 3 4 1 5 6 2 0

5.获取二叉树高度/深度

// 获取二叉树树高/深度
func (node *BinaryTreeNode) TreeHeight() int {
	// 容错处理，同时也是递归出口
	if node == nil {
		return 0 // 不能返回-1，否则少一个深度
	}
	// 左子树递归探求深度
	lch := node.Lchild.TreeHeight()
	// 右子树递归探求深度
	rch := node.Rchild.TreeHeight()
	if lch > rch {
		// 每一次递归深度自增
		lch++
		return lch
	} else {
		// 每一次递归深度自增
		rch++
		return rch
	}
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	th := tree.TreeHeight()
	fmt.Println("二叉树书高：", th)
}

4

6.获取二叉树叶子节点数

// 获取二叉树叶子节点数
func (node *BinaryTreeNode) LeafNumber() (number int) {
	// 容错处理
	if node == nil {
		return
	}
	// 判断是否是叶子节点：左子树为nil，同时右子树也为nil
	if node.Lchild == nil && node.Rchild == nil {
		number++
	}
	// 左子树（Lchild）递归调用
	number += node.Lchild.LeafNumber()
	// 右子树（Rchild）递归调用
	number += node.Rchild.LeafNumber()
	return
}

// 获取二叉树叶子节点数--指针传参
func (node *BinaryTreeNode) LeafNumber2(number *int) {
	// 容错处理
	if node == nil {
		return
	}
	// 判断是否是叶子节点：左子树为nil，同时右子树也为nil
	if node.Lchild == nil && node.Rchild == nil {
		*number++
	}
	// 左子树（Lchild）递归调用
	node.Lchild.LeafNumber2(number)
	// 右子树（Rchild）递归调用
	node.Rchild.LeafNumber2(number)
	return
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	number := tree.LeafNumber()
	fmt.Println("二叉树叶子节点：", number)
	num := 0
	tree.LeafNumber2(&num)
	fmt.Println("二叉树叶子节点：", num)
}

4

7.查找二叉树数据

// 查找二叉树数据
func (node *BinaryTreeNode) Search(data interface{}, b *bool) {
	if node == nil || data == nil {
		return
	}
	// 比较数据类型和值是否一致
	if reflect.DeepEqual(node.Data, data) && reflect.TypeOf(node.Data) == reflect.TypeOf(data) {
		*b = true
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.Search(data, b)
	// 右子树（Rchild）递归调用
	node.Rchild.Search(data, b)
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	number := 13
	b := false
	tree.Search(number, &b)
	fmt.Printf("二叉树是否存在数据 %d : %v\r\n", number, b)
}

8.销毁二叉树

// 销毁二叉树
func (node *BinaryTreeNode) Destroy() {
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.Destroy()
	// 销毁数据，促使GC工作
	node.Data = nil
	node.Lchild = nil

	// 右子树（Rchild）递归调用
	node.Rchild.Destroy()
	// 销毁数据，促使GC工作
	node.Data = nil
	node.Rchild = nil
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("销毁前：")
	tree.PreOrderPrint()
	fmt.Println()
	tree.Destroy()
	fmt.Println("销毁后:")
	tree.PreOrderPrint()
}

或者可以直接tree = nil

9.翻转（满二叉树）

完全二叉树

  • 除最后一层外，每一层的结点数都达到最大值。（左子、右子都不缺）
  • “满二叉树” 是“完全二叉树”的特例！
    在这里插入图片描述

满二叉树

每个结点都有 左子结点、右子结点 的 二叉树。

在这里插入图片描述
将创建二叉树的7的叶子节点注释掉形成满二叉树：

// 根据图创建二叉树
func (node *BinaryTreeNode) CreateBinaryTree() {
	if node == nil {
		return
	}
	node1 := &BinaryTreeNode{1, nil, nil}
	node2 := &BinaryTreeNode{2, nil, nil}
	node3 := &BinaryTreeNode{3, nil, nil}
	node4 := &BinaryTreeNode{4, nil, nil}
	node5 := &BinaryTreeNode{5, nil, nil}
	node6 := &BinaryTreeNode{6, nil, nil}
	// node7 := &BinaryTreeNode{7, nil, nil}

	node.Data = 0
	node.Lchild = node1

	node1.Lchild = node3
	node1.Rchild = node4
	// node3.Lchild = node7

	node.Rchild = node2
	node2.Lchild = node5
	node2.Rchild = node6
}

翻转操作

// 二叉树翻转(满二叉树)
func (node *BinaryTreeNode) Reverse() {
	if node == nil {
		return
	}
	// 左子树和右子树交换位置，go的多重赋值实现
	node.Lchild, node.Rchild = node.Rchild, node.Lchild

	// 左子树（Lchild）递归调用
	node.Lchild.Reverse()
	// 右子树（Rchild）递归调用
	node.Rchild.Reverse()
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("翻转前：")
	tree.PreOrderPrint()
	fmt.Println()
	tree.Reverse()
	fmt.Println("翻转后：")
	tree.PreOrderPrint()
}

翻转前：
0 1 3 4 2 5 6
翻转后：
0 2 6 5 1 4 3

10.拷贝

// 拷贝二叉树
func (node *BinaryTreeNode) Copy() *BinaryTreeNode {
	// 容错处理
	if node == nil {
		return nil
	}
	// 左子树（Lchild）递归调用,得到左子树
	oldLChild := node.Lchild.Copy()
	// 右子树（Rchild）递归调用,得到右子树
	oldRChild := node.Rchild.Copy()

	// 创建新结点并赋值
	newBinaryTreeNode := new(BinaryTreeNode)
	newBinaryTreeNode.Data = node.Data
	newBinaryTreeNode.Lchild = oldLChild
	newBinaryTreeNode.Rchild = oldRChild

	return newBinaryTreeNode
}

测试

func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("原二叉树：")
	tree.PreOrderPrint()
	fmt.Println("\r\n拷贝的二叉树：")
	newTree := tree.Copy()
	newTree.PreOrderPrint()
	fmt.Println("\r\n修改拷贝的二叉树，测试修改是否导致原二叉树的变化：")
	newTree.Lchild.Data = 666
	fmt.Println("原二叉树：")
	tree.PreOrderPrint()
	fmt.Println("\r\n拷贝并将左子树的数值修改为666的二叉树：")
	newTree.PreOrderPrint()
}

原二叉树：
0 1 3 7 4 2 5 6
拷贝的二叉树：
0 1 3 7 4 2 5 6
修改拷贝的二叉树，测试修改是否导致原二叉树的变化：
原二叉树：
0 1 3 7 4 2 5 6
拷贝并将左子树的数值修改为666的二叉树：
0 666 3 7 4 2 5 6

11.完整代码

package main

import (
	"fmt"
	"reflect"
)

// 定义二叉树结点结构体
type BinaryTreeNode struct {
	// 数据域
	Data interface{}
	// 左子结点
	Lchild *BinaryTreeNode
	// 右子结点
	Rchild *BinaryTreeNode
}

// 根据图创建二叉树
func (node *BinaryTreeNode) CreateBinaryTree() {
	if node == nil {
		return
	}
	node1 := &BinaryTreeNode{1, nil, nil}
	node2 := &BinaryTreeNode{2, nil, nil}
	node3 := &BinaryTreeNode{3, nil, nil}
	node4 := &BinaryTreeNode{4, nil, nil}
	node5 := &BinaryTreeNode{5, nil, nil}
	node6 := &BinaryTreeNode{6, nil, nil}
	node7 := &BinaryTreeNode{7, nil, nil}

	node.Data = 0
	node.Lchild = node1

	node1.Lchild = node3
	node1.Rchild = node4
	node3.Lchild = node7

	node.Rchild = node2
	node2.Lchild = node5
	node2.Rchild = node6
}

// 打印二叉树---先序遍历DLR：先根、再左、再右
func (node *BinaryTreeNode) PreOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 根（Data）
	fmt.Print(node.Data, " ")
	// 左子树（Lchild）递归调用
	node.Lchild.PreOrderPrint()
	// 右子树（Rchild）递归调用
	node.Rchild.PreOrderPrint()
}

// 打印二叉树---中序遍历LDR：先左、再根、再右
func (node *BinaryTreeNode) MidOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.MidOrderPrint()
	// 根（Data）
	fmt.Print(node.Data, " ")
	// 右子树（Rchild）递归调用
	node.Rchild.MidOrderPrint()
}

// 打印二叉树---后序遍历LRD：先左、再右、再根
func (node *BinaryTreeNode) PostOrderPrint() {
	// 容错处理，同时也是递归出口
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.PostOrderPrint()

	// 右子树（Rchild）递归调用
	node.Rchild.PostOrderPrint()
	// 根（Data）
	fmt.Print(node.Data, " ")
}

// 获取二叉树树高/深度
func (node *BinaryTreeNode) TreeHeight() int {
	// 容错处理，同时也是递归出口
	if node == nil {
		return 0 // 不能返回-1，否则少一个深度
	}
	// 左子树递归探求深度
	lch := node.Lchild.TreeHeight()
	// 右子树递归探求深度
	rch := node.Rchild.TreeHeight()
	if lch > rch {
		// 每一次递归深度自增
		lch++
		return lch
	} else {
		// 每一次递归深度自增
		rch++
		return rch
	}
}

// 获取二叉树叶子节点数
func (node *BinaryTreeNode) LeafNumber() (number int) {
	// 容错处理
	if node == nil {
		return
	}
	// 判断是否是叶子节点：左子树为nil，同时右子树也为nil
	if node.Lchild == nil && node.Rchild == nil {
		number++
	}
	// 左子树（Lchild）递归调用
	number += node.Lchild.LeafNumber()
	// 右子树（Rchild）递归调用
	number += node.Rchild.LeafNumber()
	return
}

// 获取二叉树叶子节点数--指针传参
func (node *BinaryTreeNode) LeafNumber2(number *int) {
	// 容错处理
	if node == nil {
		return
	}
	// 判断是否是叶子节点：左子树为nil，同时右子树也为nil
	if node.Lchild == nil && node.Rchild == nil {
		*number++
	}
	// 左子树（Lchild）递归调用
	node.Lchild.LeafNumber2(number)
	// 右子树（Rchild）递归调用
	node.Rchild.LeafNumber2(number)
	return
}

// 查找二叉树数据
func (node *BinaryTreeNode) Search(data interface{}, b *bool) {
	if node == nil || data == nil {
		return
	}
	// 比较数据类型和值是否一致
	if reflect.DeepEqual(node.Data, data) && reflect.TypeOf(node.Data) == reflect.TypeOf(data) {
		*b = true
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.Search(data, b)
	// 右子树（Rchild）递归调用
	node.Rchild.Search(data, b)
}

// 销毁二叉树
func (node *BinaryTreeNode) Destroy() {
	if node == nil {
		return
	}
	// 左子树（Lchild）递归调用
	node.Lchild.Destroy()
	// 销毁数据，促使GC工作
	node.Data = nil
	node.Lchild = nil

	// 右子树（Rchild）递归调用
	node.Rchild.Destroy()
	// 销毁数据，促使GC工作
	node.Data = nil
	node.Rchild = nil
}

// 二叉树翻转(满二叉树)
func (node *BinaryTreeNode) Reverse() {
	if node == nil {
		return
	}
	// 左子树和右子树交换位置，go的多重赋值实现
	node.Lchild, node.Rchild = node.Rchild, node.Lchild

	// 左子树（Lchild）递归调用
	node.Lchild.Reverse()
	// 右子树（Rchild）递归调用
	node.Rchild.Reverse()
}

// 拷贝二叉树
func (node *BinaryTreeNode) Copy() *BinaryTreeNode {
	// 容错处理
	if node == nil {
		return nil
	}
	// 左子树（Lchild）递归调用,得到左子树
	oldLChild := node.Lchild.Copy()
	// 右子树（Rchild）递归调用,得到右子树
	oldRChild := node.Rchild.Copy()

	// 创建新结点并赋值
	newBinaryTreeNode := new(BinaryTreeNode)
	newBinaryTreeNode.Data = node.Data
	newBinaryTreeNode.Lchild = oldLChild
	newBinaryTreeNode.Rchild = oldRChild

	return newBinaryTreeNode
}
func main() {
	tree := new(BinaryTreeNode)
	tree.CreateBinaryTree()
	fmt.Println("原二叉树：")
	tree.PreOrderPrint()
	fmt.Println("\r\n拷贝的二叉树：")
	newTree := tree.Copy()
	newTree.PreOrderPrint()
	fmt.Println("\r\n修改拷贝的二叉树，测试修改是否导致原二叉树的变化：")
	newTree.Lchild.Data = 666
	fmt.Println("原二叉树：")
	tree.PreOrderPrint()
	fmt.Println("\r\n拷贝并将左子树的数值修改为666的二叉树：")
	newTree.PreOrderPrint()
}
蔻蔻哒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
binarytree:Golang中的二叉树
05-14
二叉树 Golang中的二叉树实现。 当需要对类似于内部地图的数据结构进行低级控制时，可以使用此软件包： 有序地图下一个/上一个范围查询执照该软件包在MIT许可下是开源的。 有关详细信息，请参阅。
leetcode:golang leetcode
03-19
数据结构和算法是一个程序员的基石，本仓库用于个人学习基本数据...对称二叉树 简单 二叉树 位1的个数 简单 数学 118 杨辉三角 斑点 167 两数之和II 简单 斑点 206 反转链表 简单 链表 209 长度最小的子数组 中等 斑点
golang常见算法之二叉树
SMILY12138的博客
04-11 237
二叉树是一种常见的数据结构，在计算机科学中被广泛使用。本文将介绍二叉树的概念、实现方法和应用场景，以及在Golang中如何实现二叉树。
二叉搜索树(golang)
weixin_42815827的博客
12-28 424
二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：
Golang二叉树的4种遍历方式（先序，中序，后序，层序）
Lyon_Nee的博客
07-28 2764
本文只涉及使用Golang实现的（普通）二叉树的先序、中序、后序和层序的递归遍历方式。 二叉树 树的任意节点至多包含两棵子树。 二叉树的遍历 二叉树的遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。 题目数据 我们以上面的这个二叉树图为基础数据编写代码 Code 基础结构 二叉树需要存储自身节点数据，以及最多两个子节点的索引 type BinaryTree struct { Value int
【golang 必备算法】二叉树篇（一）
weixin_45901764的博客
11-19 301
144. 二叉树的前序遍历 方法一：递归 func preorderTraversal(root *TreeNode) []int { arr:=[]int{} dfs(root,&arr) //传地址 return arr } func dfs(root *TreeNode,arr *[]int){ if root==nil{ return } *arr=append(*arr,root.Val) dfs(root.Left,arr)
golang数据结构篇之二叉树
清风
11-23 835
二叉树二叉树遍历递归遍历前序非递归中序非递归后续非递归DFS 深搜-从上到下DFS 深搜-从下向上（分治法）BFS 层次遍历 二叉树遍历 前序遍历：先访问根节点，再前序遍历左子树，再前序遍历右子树 中序遍历：先中序遍历左子树，再访问根节点，再中序遍历右子树 后序遍历：先后序遍历左子树，再后序遍历右子树，再访问根节点 以根访问顺序决定是什么遍历 左子树都是优先右子树 递归遍历 前中后序递归遍历换换位置即可 func preorderTraversal(root *TreeNode) { if root
Golang mk教程-Go语言视频零基础入门到精通项目实战web编程
05-12
第05天-进阶-排序、链表、二叉树、接口 第06天-进阶-接口与反射详解 第07天-进阶-接口实例、终端文件读写、异常处理 第08天-进阶-goroute详解、定时器与单元测试 第09天-高级-网络协议TCP、Redis与聊天室 第10天-...
Leetcode-Golang:Go中的Leetcode解决方案
03-31
Leetcode-Golang Go中的Leetcode解决方案 请给这个仓库 :star: 如果它启发了你。 简单 LC＃ 描述 一维数组的运行总和 糖果数量最多的孩子 两次总和 分发糖果 多少个数字小于当前数字 计算符合规则的项目 设置...
深入遍历二叉树的各种操作详解（非递归遍历）
01-01
先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，...
GO语言实现二叉树基本功能
g2020161853的博客
04-18 268
用go语言和递归算法完成二叉树的遍历、求结点数、求深度等操作。
二叉树的左、右视图
hxxx1314的博客
12-06 1614
二叉树的右视图（剑指Offer II 046） 给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 输入: [1,2,3,null,5,null,4] 输出: [1,3,4] 思路：右视图即为二叉树每层最后一个节点 class Solution { public List<Integer> rightSideView(TreeNode root) { List<Integer> result = n
数据结构与算法 — 树的常见操作（Golang）
Mr_XiMu的博客
03-13 1617
树的常见操作 — 基于Golang语言的实现
Golang 学习十七（二叉树）
shenyuanhaojie的博客
04-09 3171
文章目录1. 前序遍历2. 中序遍历3. 后序遍历 满足以下两个条件的树就是二叉树： 本身是有序树 树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2 1. 前序遍历 前序遍历二叉树（根左右） package main import "fmt" type Student struct { Name string Age int Score float32 // 左子树指针 left *Student // 右子树指针 right
Golang二叉树
Python私教
11-23 305
代码实现 package zgo_algorithm import ( "fmt" "sync" ) // 二叉树 type TreeNode struct { Data interface{} // 节点用来存放数据 Left *TreeNode // 左子树 Right *TreeNode // 右字树 } // 先序遍历：先访问根节点，再访问左子树，最后访问右子树。 func PreOrder(tree *TreeNode) { if tree == nil { ret
go语言实现--二叉树
米兰的小铁匠1943的博客
03-10 9334
二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_0...
Golang 数据结构：二叉搜索树
最新发布
憧憬个人博客
07-11 127
Insert(v) // 向二叉搜索树的合适位置插入节点 Search(k) // 检查序号为 k 的元素在树中是否存在 Remove(v) // 移除树中所有值为 v 的节点 Min() // 获取二叉搜索树中最小的值 Max() // 获取二叉搜索树中最大的值 InOrderTraverse() // 中序遍历树 PreOrderTraverse() // 先序遍历树 PostOrderTraverse() // 后续遍历树 String() // 在命令行格式化打印出二叉树。
Golang 数据结构实现之 二叉树
weixin_34178244的博客
03-18 181
二叉树的理论知识，应该都比较了解了，下文不再详细介绍二叉树的基本知识。 在二叉树中具有以下重要性质： 1.在二叉树的第i层上最多有(2的i次方)个结点。 2.高度为h的二叉树至多有(2的h+1次方-1)个结点。 3.对任何一棵二叉树，如果其终端结点(叶子结点)数为n0，度为2的结点数为n2，则n0 = n2 + 1。 下面就直接贴出gol...
golang ----------- 二叉树的建立
田园园野的博客
05-09 3200
1、由标明空子树的先跟遍历序列建立一颗二叉树的操作算法var i = -1 func HaveEmptyCreate(arr []int) *TreeNode{ i=i+1 if i &gt;= len(arr){ return nil } var t TreeNode if arr[i] != 0 { t = TreeNode{nil,arr[i],nil} t.Left ...
golang二叉树的最长直径
05-25
下面是使用 Golang 实现二叉树的最长直径的代码： ```go type TreeNode struct { Val int Left *TreeNode Right *TreeNode } func maxDepth(root *TreeNode) int { if root == nil { return 0 } return max...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值