(1)二叉树的定义
二叉树是 n 个有限元素的集合,该集合或者为空、或者由一个称为根( root )的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成,是有序树。当集合为空时,称该二叉树为空二叉树,在二叉树中,一个元素也称作一个节点 。
二叉树是将一般的树加上以下的两个限制条件:
每个结点最多只有两棵子树,即二叉树中结点的度只能为 0、1、2;
子树有左右顺序之分,不能颠倒。
根据二叉树的定义可知,二叉树共有 5 种基本形态:空二叉树、只有根结点、只有左子树,右子树为空、只有右子树,左子树为空、既有左子树,又有右子树。
(2)特殊类型
满二叉树:如果一棵二叉树只有度为 0 的节点和度为 2 的节点,并且度为 0 的节点在同一层上,则这棵二叉树为满二叉树。
完全二叉树:深度为 k ,有 n 个节点的二叉树当且仅当其每一个节点都与深度为 k 的满二叉树中编号从 1 到 n 的节点一一对应时,称为完全二叉树。
(3)二叉树的性质
性质① :二叉树的第 i 层上至多有 2i-1( i≥1 )个节点。
性质② :深度为 h 的二叉树中至多含有 2h-1 个节点。
性质③ :若在任意一棵二叉树中,有 n0 个叶子节点,有 n2 个度为 2 的节点,则必有 n0 = n2 + 1 。
性质④ :具有 n 个节点的满二叉树深为 log2n+1 。
性质⑤ :若对一棵有 n 个节点的完全二叉树进行顺序编号( 1≤i≤n ),那么,对于编号为 i( i≥1 )的节点: 当 i=1 时,该节点为根,它无双亲节点;当 i>1 时,该节点的双亲节点的编号为 i/2 ;若2i≤n ,则有编号为 2i 的左节点,否则没有左节点;若 2i+1≤n ,则有编号为 2i+1 的右节点,否则没有右节点。
(1)先序遍历
先访问根节点,然后遍历左子树,最后遍历右子树。
(2)中序遍历
先遍历左子树,访问根结点,遍历右子树。
(3)后序遍历
先遍历左子树,再遍历右子树,最后访问根结点。
(1)先序遍历
非递归方式遍历二叉树,需要引入额外的数据结构栈,其基本流程如下:
初始化一个栈,将根节点入栈。
当栈不为空时:
(2)中序遍历
初始化一个空栈。
当根结点不为空或栈不为空时,从根节点开始:
(3)后序遍历
初始化一个空栈。
当根节点不为空或栈不为空时,从根节点开始:
二叉树的层次遍历,是指从二叉树的第一层(根结点开始)自上而下逐层遍历,同层内按照从左至右的顺序逐个节点访问。
首先根节点入队,当队列非空时,重复如下两步操作。
(1)在任意目录下创建项目,编写一个名为 recursion.go
的程序实现二叉树的递归遍历,该程序的具体代码如下所示。
package Recursion
import (
"fmt"
)
type BinaryTreeNode struct {
Value interface{}
Lchild *BinaryTreeNode
Rchild *BinaryTreeNode
}
func NewBinaryTreeNode(v interface{}) *BinaryTreeNode {
return &BinaryTreeNode{Value: v}
}
type Operate interface {
// 打印结点的值
PrintValue()
// 递归先序遍历
PreOrder()
// 递归中序遍历
InOrder()
// 递归后序遍历
PostOrder()
}
func (b *BinaryTreeNode) PrintValue() {
fmt.Printf(" %d ", b.Value)
}
func (b *BinaryTreeNode) PreOrder() {
if b == nil {
return
} else {
// 递归访问根节点
b.PrintValue()
// 递归访问左子树
b.Lchild.PreOrder()
// 递归访问右子树
b.Rchild.PreOrder()
}
}
func (b *BinaryTreeNode) InOrder() {
if b == nil {
return
} else {
// 递归访问左子树
b.Lchild.InOrder()
// 递归访问根节点
b.PrintValue()
// 递归访问右子树
b.Rchild.InOrder()
}
}
func (b *BinaryTreeNode) PostOrder() {
if b == nil {
return
} else {
// 递归访问左子树
b.Lchild.PostOrder()
// 递归访问右子树
b.Rchild.PostOrder()
// 递归访问根节点
b.PrintValue()
}
}
(2)在项目目录下编写一个名为 recursion_test.go
的程序测试以上遍历逻辑是否正确,该程序的具体代码如下所示。
package Recursion
import (
"fmt"
"testing"
)
func TestRangeBinaryTree(t *testing.T) {
var bt Operate
root := NewBinaryTreeNode(5)
root.Lchild = NewBinaryTreeNode(3)
root.Rchild = NewBinaryTreeNode(1)
root.Lchild.Lchild = NewBinaryTreeNode(9)
root.Rchild.Rchild = NewBinaryTreeNode(6)
bt = root
fmt.Println("二叉树递归先序遍历:")
bt.PreOrder()
fmt.Println()
fmt.Println("二叉树递归中序遍历:")
bt.InOrder()
fmt.Println()
fmt.Println("二叉树递归后序遍历:")
bt.PostOrder()
fmt.Println()
}
(3)在该项目目录下执行 go test
命令,程序运行的结果如下所示。
二叉树递归先序遍历:
5 3 9 1 6
二叉树递归中序遍历:
9 3 5 1 6
二叉树递归后序遍历:
9 3 6 1 5
PASS
ok
(1)在任意目录下创建项目,编写一个名为 notrecursion.go
的程序实现二叉树的递归遍历,该程序的具体代码如下所示。
package NotRecursion
import (
"fmt"
)
type BinaryTreeNode struct {
Value interface{}
Lchild *BinaryTreeNode
Rchild *BinaryTreeNode
}
func NewBinaryTreeNode(v interface{}) *BinaryTreeNode {
return &BinaryTreeNode{Value: v}
}
type Operate interface {
// 打印结点的值
PrintValue()
// 非递归先序遍历
ReCallPreOrder()
// 非递归中序遍历
ReCallInOrder()
// 非递归后序遍历
ReCallPostOrder()
}
func (b *BinaryTreeNode) PrintValue() {
fmt.Printf(" %d ", b.Value)
}
func (b *BinaryTreeNode) ReCallPreOrder() {
St := make([]*BinaryTreeNode, 20)
top := -1
// 根结点非空,根节点进栈
if b != nil {
top++
St[top] = b
// 栈非空时循环
for top > -1 {
// 退栈并访问该节点
p := St[top]
top--
fmt.Printf(" %d ", p.Value)
// 存在右孩子,将其进栈
if p.Rchild != nil {
top++
St[top] = p.Rchild
}
// 存在左孩子,将其进栈
if p.Lchild != nil {
top++
St[top] = p.Lchild
}
}
fmt.Println()
}
}
func (b *BinaryTreeNode) ReCallInOrder() {
St := make([]*BinaryTreeNode, 20)
top := -1
if b != nil {
p := b
// 根结点非空或栈非空时循环
for top > -1 || p != nil {
// 扫描节点 p 的所有左下节点并进栈
for p != nil {
top++
St[top] = p
p = p.Lchild
}
if top > -1 {
// 出栈节点 p 并访问
p = St[top]
top--
fmt.Printf(" %d ", p.Value)
p = p.Rchild
}
}
fmt.Println()
}
}
func (b *BinaryTreeNode) ReCallPostOrder() {
St := make([]*BinaryTreeNode, 20)
top := -1
p := new(BinaryTreeNode)
var flag bool
// 根结点非空时循环
if b != nil {
for {
for b != nil {
// 将 b 结点的所有左下结点进栈
top++
St[top] = b
b = b.Lchild
}
// p 指向当前节点的前一个已经访问过的节点
p = nil
// flag 为 true 时,表示正在处理栈顶节点
flag = true
for top != -1 && flag {
// 取出当前的栈顶元素
b = St[top]
// 若右子树不存在或已被访问,访问 b 节点
if b.Rchild == p {
fmt.Printf(" %d ", b.Value)
top--
// p 指向被访问的节点
p = b
} else {
// b 指向右子树
b = b.Rchild
// flag 为 false 时,表明当前不是处理的栈顶节点
flag = false
}
}
if top == -1 {
break
}
}
fmt.Println()
}
}
(2)在项目目录下编写一个名为 notrecursion_test.go
的程序测试以上遍历逻辑是否正确,该程序的具体代码如下所示。
package NotRecursion
import (
"fmt"
"testing"
)
func TestRangeBinaryTree(t *testing.T) {
var bt Operate
root := NewBinaryTreeNode(5)
root.Lchild = NewBinaryTreeNode(3)
root.Rchild = NewBinaryTreeNode(1)
root.Lchild.Lchild = NewBinaryTreeNode(9)
root.Rchild.Rchild = NewBinaryTreeNode(6)
bt = root
fmt.Println("二叉树非递归先序遍历:")
bt.ReCallPreOrder()
fmt.Println("二叉树非递归中序遍历:")
bt.ReCallInOrder()
fmt.Println("二叉树非递归后序遍历:")
bt.ReCallPostOrder()
}
(3)在该项目目录下执行 go test
命令,程序运行的结果如下所示。
二叉树非递归先序遍历:
5 3 9 1 6
二叉树非递归中序遍历:
9 3 5 1 6
二叉树非递归后序遍历:
9 3 6 1 5
PASS
ok
(1)在任意目录下创建项目,编写一个名为 travlevel.go
的程序实现二叉树的递归遍历,该程序的具体代码如下所示。
package TravLevel
import (
"fmt"
)
type BinaryTreeNode struct {
Value interface{}
Lchild *BinaryTreeNode
Rchild *BinaryTreeNode
}
func NewBinaryTreeNode(v interface{}) *BinaryTreeNode {
return &BinaryTreeNode{Value: v}
}
type Operate interface {
PrintValue()
TravLevel()
}
func (b *BinaryTreeNode) PrintValue() {
fmt.Printf(" %d ", b.Value)
}
func (b *BinaryTreeNode) TravLevel() {
// 定义环形队列
const MaxSize = 20
var Queue [MaxSize]*BinaryTreeNode
// 定义对首和队尾指针并置队列为空
front, rear := 0, 0
if b != nil {
fmt.Printf(" %d ", b.Value)
}
// 根节点不为空进队
rear++
Queue[rear] = b
// 队列不为空时循环
for front != rear {
// 出队节点 b
front = (front + 1) % MaxSize
b = Queue[front]
if b.Lchild != nil {
// 输出左孩子并进队
fmt.Printf(" %d ", b.Lchild.Value)
rear = (rear + 1) % MaxSize
Queue[rear] = b.Lchild
}
if b.Rchild != nil {
// 输出右孩子并进队
fmt.Printf(" %d ", b.Rchild.Value)
rear = (rear + 1) % MaxSize
Queue[rear] = b.Rchild
}
}
fmt.Println()
}
(2)在项目目录下编写一个名为 travlevel_test.go
的程序测试以上遍历逻辑是否正确,该程序的具体代码如下所示。
package TravLevel
import (
"fmt"
"testing"
)
func TestRangeBinaryTree(t *testing.T) {
var bt Operate
root := NewBinaryTreeNode(5)
root.Lchild = NewBinaryTreeNode(3)
root.Rchild = NewBinaryTreeNode(1)
root.Lchild.Lchild = NewBinaryTreeNode(9)
root.Rchild.Rchild = NewBinaryTreeNode(6)
bt = root
fmt.Println("二叉树层次遍历:")
bt.TravLevel()
}
(3)在该项目目录下执行 go test
命令,程序运行的结果如下所示。
二叉树递归先序遍历:
5 3 9 1 6
二叉树递归中序遍历:
9 3 5 1 6
二叉树递归后序遍历:
9 3 6 1 5
PASS
ok
参考书籍:《数据结构教程 第6版》(李春葆 主编)
参考书籍:《数据结构 C语言版》(严蔚敏、李冬梅、吴伟民著)