關(guān)于二叉樹的代碼實(shí)現(xiàn)，這里主要介紹的是完全二叉樹的情形。
引用百度百科上對(duì)完全二叉樹的判定：若設(shè)二叉樹的深度為h，除第 h 層外，其它各層 (1～h-1) 的結(jié)點(diǎn)數(shù)都達(dá)到最大個(gè)數(shù)，第 h 層所有的結(jié)點(diǎn)都連續(xù)集中在最左邊，這就是完全二叉樹。
代碼結(jié)構(gòu)如下

tree文件的代碼如下:

package tree

import "fmt"

type Object interface{}

type TreeNode struct {
    Data       Object
    LeftChild  *TreeNode
    RightChild *TreeNode
}

//(完全)二叉樹結(jié)構(gòu)
type Tree struct {
    RootNode *TreeNode
}

//追加元素 (廣度優(yōu)先，即按層級(jí)遍歷后添加)
func (this *Tree) Add(object Object) {
    node := &TreeNode{Data: object}
    if this.RootNode == nil {
        this.RootNode = node
        return
    }
    queue := []*TreeNode{this.RootNode}
    for len(queue) != 0 {
        cur_node := queue[0]
        queue = queue[1:]

        if cur_node.LeftChild == nil {
            cur_node.LeftChild = node
            return
        } else {
            queue = append(queue, cur_node.LeftChild)
        }
        if cur_node.RightChild == nil {
            cur_node.RightChild = node
            return
        } else {
            queue = append(queue, cur_node.RightChild)
        }
    }
}

//廣度遍歷
func (this *Tree) BreadthTravel() {

    if this.RootNode == nil {
        return
    }
    queue := []*TreeNode{}
    queue = append(queue, this.RootNode)

    for len(queue) != 0 {
        //fmt.Printf("len(queue):%d\n", len(queue))
        cur_node := queue[0]
        queue = queue[1:]

        fmt.Printf("%v  ", cur_node.Data)

        if cur_node.LeftChild != nil {
            queue = append(queue, cur_node.LeftChild)
        }
        if cur_node.RightChild != nil {
            queue = append(queue, cur_node.RightChild)
        }
    }

}

/*
深度遍歷:
1.先序遍歷:根->左->右
2.中序遍歷:左->中->右
3.后序遍歷:左->右->根
*/

//先序遍歷
func (this *Tree) PreOrder(node *TreeNode) {
    if node == nil {
        return
    }

    fmt.Printf("%v  ", node.Data)

    //if node.LeftChild != nil {
    this.PreOrder(node.LeftChild)
    //}
    //if node.RightChild != nil {
    this.PreOrder(node.RightChild)
    //}
}


//中序遍歷
func (this *Tree) InOrder(node *TreeNode) {
    if node == nil {
        return
    }
    this.InOrder(node.LeftChild)
    fmt.Printf("%v  ", node.Data)
    this.InOrder(node.RightChild)
}

func (this *Tree) PostOrder(node *TreeNode)  {
    if node == nil {
        return
    }
    this.PostOrder(node.LeftChild)
    this.PostOrder(node.RightChild)
    fmt.Printf("%v  ", node.Data)
}

其中相關(guān)main函數(shù)的測試代碼如下：

package main

import (
    "fmt"
    "algorithm/queue"
    "algorithm/tree"
)

func main() {
    tree := tree.Tree{}
    tree.Add(0)
    tree.Add(1)
    tree.Add(2)
    tree.Add(3)
    tree.Add(4)
    tree.Add(5)
    tree.Add(6)
    tree.Add(7)
    tree.Add(8)
    tree.Add(9)

    //廣度優(yōu)先遍歷
    //tree.BreadthTravel()
    //fmt.Println("")

    //深度優(yōu)先 先序遍歷
    tree.PreOrder(tree.RootNode)
    fmt.Println("")

    //深度優(yōu)先  中序遍歷
    tree.InOrder(tree.RootNode)
    fmt.Println("")

    //深度優(yōu)先  后序遍歷
    tree.PostOrder(tree.RootNode)
    fmt.Println("")
}