二叉树的遍历，格式化输出，最大值，最小值

点击个人博客，查看更多文章https://elonjelinek.github.io/

package main

import (
	"fmt"
)

// 树的节点
type Node struct {
	Value int
	Left  *Node
	Right *Node
}

// 树
type BinarySearchTree struct {
	root *Node
}

// 格式化输出
func (tree *BinarySearchTree) String() {
	fmt.Println("格式化输出：")
	fmt.Println("--------------------------------")
	stringify(tree.root, 0)
	fmt.Println("--------------------------------")
}

func stringify(node *Node, level int) {
	if node != nil {
		format := ""
		for i := 0; i < level; i++ {
			format += "       "
		}

		format += "---[ "
		level++

		stringify(node.Right, level)
		fmt.Printf(format+"%d\n", node.Value)
		stringify(node.Left, level)
	}
}

// 插入节点
func (tree *BinarySearchTree) Insert(Value int) {
	node := &Node{Value, nil, nil}
	if tree.root == nil {
		tree.root = node
	} else {
		insertNode(tree.root, node)
	}
}

func insertNode(node, newNode *Node) {
	if newNode.Value < node.Value {
		if node.Left == nil {
			node.Left = newNode
		} else {
			insertNode(node.Left, newNode)
		}
	} else {
		if node.Right == nil {
			node.Right = newNode
		} else {
			insertNode(node.Right, newNode)
		}
	}
}

// 最小的节点
func (tree *BinarySearchTree) Min() int {
	node := tree.root

	if node == nil {
		return 0
	}

	for {
		if node.Left == nil {
			return node.Value
		}

		node = node.Left
	}
}

// 最大的节点
func (tree *BinarySearchTree) Max() int {
	node := tree.root

	if node == nil {
		return 0
	}

	for {
		if node.Right == nil {
			return node.Value
		}
		node = node.Right
	}
}

// 查找指定节点
func (tree *BinarySearchTree) Search(Value int) bool {
	fmt.Print("是否存在节点：", Value, "\t")
	return search(tree.root, Value)
}

func search(node *Node, Value int) bool {
	if node == nil {
		return false
	}

	if Value < node.Value {
		return search(node.Left, Value)
	}

	if Value > node.Value {
		return search(node.Right, Value)
	}

	return true
}

// 删除节点
func (tree *BinarySearchTree) Remove(Value int) {
	fmt.Println("删除节点：", Value)
	remove(tree.root, Value)
}

func remove(node *Node, Value int) *Node {
	if node == nil {
		return nil
	}

	if Value < node.Value {
		node.Left = remove(node.Left, Value)
		return node
	}

	if Value > node.Value {
		node.Right = remove(node.Right, Value)
		return node
	}

	if node.Left == nil && node.Right == nil {
		node = nil
		return node
	}

	if node.Left == nil {
		node = node.Right
		return node
	}

	if node.Right == nil {
		node = node.Left
		return node
	}

	mostLeftNode := node.Right
	for {
		if mostLeftNode != nil && mostLeftNode.Left != nil {
			mostLeftNode = mostLeftNode.Left
		} else {
			break
		}
	}

	node.Value, node.Value = mostLeftNode.Value, mostLeftNode.Value
	node.Right = remove(node.Right, node.Value)
	return node
}

func (tree *BinarySearchTree) PreOrderTraverse(node *Node) {
	if node == nil {
		return
	}
	fmt.Print(node.Value, "\t")
	tree.PreOrderTraverse(node.Left)
	tree.PreOrderTraverse(node.Right)
}

func (tree *BinarySearchTree) PostOrderTraverse() {
	fmt.Println("后序遍历：")
	node := tree.root
	postOrder(node)
	fmt.Println()
}

func postOrder(node *Node) {
	if node == nil {
		return
	}
	postOrder(node.Left)
	postOrder(node.Right)
	fmt.Print(node.Value, "\t")
}

func (tree *BinarySearchTree) InOrderTraverse() {
	fmt.Println("中序遍历：")
	node := tree.root
	InOrder(node)
	fmt.Println()
}

func InOrder(node *Node) {
	if node != nil {
		InOrder(node.Left)
		fmt.Print(node.Value, "\t")
		InOrder(node.Right)
	}
}

//广度优先
func breadthFirst(node *Node) []int {
	fmt.Println("广度优先遍历：")
	var result []int
	var nodes = []Node{*node}

	for len(nodes) > 0 {
		node := nodes[0]
		nodes = nodes[1:]
		result = append(result, node.Value)
		if node.Left != nil {
			nodes = append(nodes, *node.Left)
		}
		if node.Right != nil {
			nodes = append(nodes, *node.Right)
		}
	}

	return result
}

//二叉树的深度
func GetDepth(node *Node) int {
	depth := 0
	if node != nil {
		depth = max(GetDepth(node.Left), GetDepth(node.Right)) + 1
	}
	return depth
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func GetDepth2(node *Node) int {
	if node == nil {
		return 0
	}
	return max(GetDepth2(node.Left), GetDepth2(node.Right)) + 1
}

func (tree *BinarySearchTree) FindLCA(node *Node, Value1 int, Value2 int) {
	fmt.Print(Value1, "和", Value2, "的最小共同父节点为：")
	lca := findLCA(node, Value1, Value2)
	fmt.Println(lca.Value)
}

func findLCA(node *Node, Value1 int, Value2 int) *Node {
	if node == nil {
		return nil
	}
	if node.Value == Value1 || node.Value == Value2 {
		return node
	}
	var LeftNode = new(Node)
	LeftNode = findLCA(node.Left, Value1, Value2)
	var RightNode = new(Node)
	RightNode = findLCA(node.Right, Value1, Value2)
	if LeftNode != nil && RightNode != nil {
		return node
	}
	if LeftNode != nil {
		return LeftNode
	}
	return RightNode
}

func (tree *BinarySearchTree) FindLevel(node *Node, Value int) {
	level := 1
	lev := findLevel(node, Value, level)
	fmt.Println(Value, "在第", lev, "层。")
}

func findLevel(node *Node, Value int, level int) int {
	if node == nil {
		return -1
	}
	if node.Value == Value {
		return level
	}
	var lev int
	lev = findLevel(node.Left, Value, level+1)
	if lev == -1 {
		return findLevel(node.Right, Value, level+1)
	} else {
		return lev
	}
}

func GetDistance(node *Node, Value1 int, Value2 int) {
	fmt.Print(Value1, "和", Value2, "的距离为：")
	dis := getDistance(node, Value1, Value2)
	fmt.Println(dis)
}

func getDistance(node *Node, Value1 int, Value2 int) int {
	lca := findLCA(node, Value1, Value2)
	disLCA := findLevel(node, lca.Value, 1)
	disValue1 := findLevel(node, Value1, 1)
	disValue2 := findLevel(node, Value2, 1)
	dis := disValue1 + disValue2 - 2*disLCA
	return dis
}

func main() {
	var tree BinarySearchTree
	tree.Insert(8)
	tree.Insert(4)
	tree.Insert(13)
	tree.Insert(2)
	tree.Insert(6)
	tree.Insert(1)
	tree.Insert(10)
	tree.Insert(12)
	tree.Insert(3)
	tree.Insert(9)
	tree.Insert(5)
	tree.Insert(7)
	tree.Insert(11)

	tree.String()

	fmt.Printf("二叉树Value最小的节点的Value值：%v\n", tree.Min())
	//fmt.Printf("二叉树Value最大的节点的Value值：%v\n", tree.Max())
	fmt.Println("最大的节点是：", tree.Max())

	fmt.Println(tree.Search(16))

	tree.Remove(8)
	tree.String()

	fmt.Println("前序遍历：")
	tree.PreOrderTraverse(tree.root)
	fmt.Println()

	tree.InOrderTraverse()

	tree.PostOrderTraverse()

	breadthTree := breadthFirst(tree.root)
	fmt.Println(breadthTree)

	fmt.Println("广度优先遍历：")
	for _, Value := range breadthTree {
		fmt.Print(Value, "\t")
		//fmt.Println(Value)
	}
	fmt.Println()

	fmt.Print("二叉树的深度：")
	fmt.Println(GetDepth(tree.root))

	fmt.Print("二叉树的深度为：")
	fmt.Println(GetDepth2(tree.root))

	tree.FindLCA(tree.root, 3, 11)

	tree.FindLevel(tree.root, 11)

	GetDistance(tree.root, 4, 10)

}

运行结果

格式化输出：
--------------------------------
       ---[ 13
                     ---[ 12
                            ---[ 11
              ---[ 10
                     ---[ 9
---[ 8
                     ---[ 7
              ---[ 6
                     ---[ 5
       ---[ 4
                     ---[ 3
              ---[ 2
                     ---[ 1
--------------------------------
二叉树Value最小的节点的Value值：1
最大的节点是： 13
是否存在节点：16	false
删除节点： 8
格式化输出：
--------------------------------
       ---[ 13
                     ---[ 12
                            ---[ 11
              ---[ 10
---[ 9
                     ---[ 7
              ---[ 6
                     ---[ 5
       ---[ 4
                     ---[ 3
              ---[ 2
                     ---[ 1
--------------------------------
前序遍历：
9	4	2	1	3	6	5	7	13	10	12	11	
中序遍历：
1	2	3	4	5	6	7	9	10	11	12	13	
后序遍历：
1	3	2	5	7	6	4	11	12	10	13	9	
广度优先遍历：
[9 4 13 2 6 10 1 3 5 7 12 11]
广度优先遍历：
9	4	13	2	6	10	1	3	5	7	12	11	
二叉树的深度：5
二叉树的深度为：5
3和11的最小共同父节点为：9
11 在第 5 层。
4和10的距离为：3

点击个人博客，查看更多文章https://elonjelinek.github.io/