Go数据结构（三）二叉树

 方法接口：

type BinTreeMethods interface {
	Insert(data int)
	insertRec(root *Node, data int)
	InOrderTraversal(root *Node)//中序遍历
	PreOrderTraversal(root *Node)//先序遍历
	PostOrderTraversal(root *Node)//后序遍历
	LevelOrderTraversal(root *Node)//层次遍历
}

全部代码：

package main

import (
	"container/list"
	"fmt"
)

// 定义二叉树节点结构
type Node struct {
	Data  int
	Left  *Node
	Right *Node
}

// BinTreeMethods 定义二叉树的方法
type BinTreeMethods interface {
	Insert(data int)
	insertRec(root *Node, data int)
	InOrderTraversal(root *Node)
	PreOrderTraversal(root *Node)
	PostOrderTraversal(root *Node)
	LevelOrderTraversal(root *Node)
}

// 二叉树结构
type BinaryTree struct {
	Root *Node
}

// 插入节点
func (t *BinaryTree) Insert(data int) {
	if t.Root == nil {
		t.Root = &Node{Data: data, Left: nil, Right: nil}
	} else {
		t.insertRec(t.Root, data)
	}
}

func (t *BinaryTree) insertRec(root *Node, data int) {
	if data < root.Data {
		if root.Left == nil {
			root.Left = &Node{Data: data, Left: nil, Right: nil}
		} else {
			t.insertRec(root.Left, data)
		}
	} else {
		if root.Right == nil {
			root.Right = &Node{Data: data, Left: nil, Right: nil}
		} else {
			t.insertRec(root.Right, data)
		}
	}
}

// 中序遍历
func (t *BinaryTree) InOrderTraversal(root *Node) {
	if root != nil {
		t.InOrderTraversal(root.Left)
		fmt.Printf("%d ", root.Data)
		t.InOrderTraversal(root.Right)
	}
}

// 先序遍历
func (t *BinaryTree) PreOrderTraversal(root *Node) {
	if root != nil {
		fmt.Printf("%d ", root.Data)
		t.PreOrderTraversal(root.Left)
		t.PreOrderTraversal(root.Right)
	}
}

// 后序遍历
func (t *BinaryTree) PostOrderTraversal(root *Node) {
	if root != nil {
		t.PostOrderTraversal(root.Left)
		t.PostOrderTraversal(root.Right)
		fmt.Printf("%d ", root.Data)
	}
}

// 层次遍历







func (t *BinaryTree) LevelOrderTraversal(root *Node) {
	if root == nil {
		return
	}
	// 创建一个空队列。
	queue := list.New()
	// 将根节点入队。
	queue.PushBack(root)
	// 循环执行以下步骤直到队列为空：
	for queue.Len() > 0 {
		// 出队当前节点。
		node := queue.Front().Value.(*Node)
		queue.Remove(queue.Front())
		// 处理当前节点（例如，打印节点的值）。
		fmt.Printf("%d ", node.Data)
		// 将当前节点的左子节点入队（如果存在）。
		if node.Left != nil {
			queue.PushBack(node.Left)
		}
		// 将当前节点的右子节点入队（如果存在）。
		if node.Right != nil {
			queue.PushBack(node.Right)
		}
	}
}

func main() {
	var tree BinTreeMethods
	tree = &BinaryTree{}

	// 插入节点
	tree.Insert(5)
	tree.Insert(3)
	tree.Insert(7)
	tree.Insert(1)
	tree.Insert(4)

	// 中序遍历
	fmt.Println("InOrder Traversal:")
	tree.InOrderTraversal(tree.(*BinaryTree).Root)
	fmt.Println()

	// 先序遍历
	fmt.Println("PreOrder Traversal:")
	tree.PreOrderTraversal(tree.(*BinaryTree).Root)
	fmt.Println()

	// 后序遍历
	fmt.Println("PostOrder Traversal:")
	tree.PostOrderTraversal(tree.(*BinaryTree).Root)
	fmt.Println()

	// 层次遍历
	fmt.Println("LevelOrder Traversal:")
	tree.LevelOrderTraversal(tree.(*BinaryTree).Root)
	fmt.Println()
}

笔记：

由二叉树的先序序列和中序序列可以唯一地确定一棵二叉树

在先序遍历序列中，第一个结点一定是二叉树的根结点;而在中序遍历中，根结点必然将中序序列分割成两个子序列，前一个子序列是根结点的左子树的中序序列，后一个子序列是根结点的右子树的中序序列。

根据这两个子序列，在先序序列中找到对应的左子序列和右子序列。

在先序序列中，左子序列的第一个结点是左子树的根结点，右子序列的第一个结点是右子树的根结点。
如此递归地进行下去，便能唯一地确定这棵二叉树。

同理，由二叉树的后序序列和中序序列也可以唯一地确定一棵二叉树。

因为后序序列的最后一个结点就如同先序序列的第一个结点，可以将中序序列分割成两个子序列，然后采用类似的方法递归地进行划分，进而得到一棵二叉树。
由二叉树的层序序列和中序序列也可以唯一地确定一棵二叉树，需要注意的是，若只知道二叉树的先序序列和后序序列，则无法唯一确定一棵二叉树。