二叉树的基础知识

（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 个节点。

• 性质③ ：若在任意一棵二叉树中，有 n₀ 个叶子节点，有 n₂ 个度为 2 的节点，则必有 n₀ = n₂ + 1 。

• 性质④ ：具有 n 个节点的满二叉树深为 log2_n+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）先序遍历

非递归方式遍历二叉树，需要引入额外的数据结构栈，其基本流程如下：

• 初始化一个栈，将根节点入栈。

• 当栈不为空时：

• • 弹出栈顶元素 node ，将该节点值加入结果数组中；
• • 若 node 的右子树不为空，右子树入栈；
• • 若 node 的左子树不为空，左子树入栈。

（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语言版》（严蔚敏、李冬梅、吴伟民著）