golang实现树遍历
package main
import (
"container/list"
"fmt"
"strings"
)
type MyStack struct {
List *list.List
}
type MyQueue struct {
List *list.List
}
type BinaryTree struct {
Value interface{}
Left *BinaryTree
Right *BinaryTree
}
type Tree struct {
Value interface{}
Children []*Tree
}
func (stack *MyStack) pop() interface{} {
if elem := stack.List.Back(); elem != nil {
stack.List.Remove(elem)
return elem.Value
}
return nil
}
func (stack *MyStack) push(elem interface{}) {
stack.List.PushBack(elem)
}
func (queue *MyQueue) pop() interface{} {
if elem := queue.List.Front(); elem != nil {
queue.List.Remove(elem)
return elem.Value
}
return nil
}
func (queue *MyQueue) push(elem interface{}) {
queue.List.PushBack(elem)
}
func preOrderRecur(node *BinaryTree) {
if node == nil {
return
}
fmt.Println(node.Value)
preOrderRecur(node.Left)
preOrderRecur(node.Right)
}
func inOrderRecu(node *BinaryTree) {
if node == nil {
return
}
inOrderRecu(node.Left)
fmt.Println(node.Value)
inOrderRecu(node.Right)
}
func posOrderRecu(node *BinaryTree) {
if node == nil {
return
}
posOrderRecu(node.Left)
posOrderRecu(node.Right)
fmt.Println(node.Value)
}
func preOrder(node *BinaryTree) {
stack := MyStack{List: list.New()}
stack.push(node)
elem := stack.pop()
for elem != nil {
node, _ := elem.(*BinaryTree)
fmt.Println(node.Value)
if right := node.Right; right != nil {
stack.push(right)
}
if left := node.Left; left != nil {
stack.push(left)
}
elem = stack.pop()
}
}
func inOrder(node *BinaryTree) {
stack := MyStack{List: list.New()}
current := node
for stack.List.Len() > 0 || current != nil {
if current != nil {
stack.push(current)
current = current.Left
} else {
current = stack.pop().(*BinaryTree)
fmt.Println(current.Value)
current = current.Right
}
}
}
func postOrder(node *BinaryTree) {
stack1, stack2 := MyStack{List: list.New()}, MyStack{List: list.New()}
stack1.push(node)
for stack1.List.Len() > 0 {
elem := stack1.pop().(*BinaryTree)
stack2.push(elem)
if elem.Left != nil {
stack1.push(elem.Left)
}
if elem.Right != nil {
stack1.push(elem.Right)
}
}
for stack2.List.Len() > 0 {
elem := stack2.pop().(*BinaryTree)
fmt.Println(elem.Value)
}
}
func levelOrder(node *BinaryTree) {
var nlast *BinaryTree
last := node
level := 1
queue := MyQueue{List: list.New()}
fmt.Println(fmt.Sprintf("-----this is %d level-----", level))
queue.push(node)
for queue.List.Len() > 0 {
node := queue.pop().(*BinaryTree)
if node.Left != nil {
queue.push(node.Left)
nlast = node.Left
}
if node.Right != nil {
queue.push(node.Right)
nlast = node.Right
}
fmt.Println(node.Value)
if last == node && (node.Left != nil || node.Right != nil) {
last = nlast
level++
fmt.Println()
fmt.Println(fmt.Sprintf("-----this is %d level-----", level))
}
}
}
func levelTreeOrder(node *Tree) {
var nlast *Tree
last := node
queue := MyQueue{List: list.New()}
queue.push(node)
for queue.List.Len() > 0 {
node := queue.pop().(*Tree)
for _, elem := range node.Children {
queue.push(elem)
nlast = elem
}
fmt.Println(node.Value)
if last == node {
last = nlast
fmt.Println()
}
}
}
func preOrderToStr(node *BinaryTree) (ret string) {
if node == nil {
return "#!"
}
ret += fmt.Sprintf("%d!", node.Value)
ret += preOrderToStr(node.Left)
ret += preOrderToStr(node.Right)
return ret
}
func strToBinaryTree(arr []string, index *int) *BinaryTree {
if *index >= len(arr) {
return nil
}
if arr[*index] == "#" {
*index++
return nil
}
node := &BinaryTree{}
node.Value = arr[*index]
*index++
node.Left = strToBinaryTree(arr, index)
node.Right = strToBinaryTree(arr, index)
return node
}
func main() {
str := "1!2!4!#!#!5!#!#!3!6!#!#!7!#!#!"
arr := strings.Split(str, "!")
index := 0
node := strToBinaryTree(arr, &index)
preOrder(node)
// -----------多叉树层次遍历（打印行号）-----------------
// node11 := &Tree{Value: 10}
// node10 := &Tree{Value: 10}
// node9 := &Tree{Value: 9}
// node8 := &Tree{Value: 8}
// node7 := &Tree{Value: 7}
// node6 := &Tree{Value: 6}
// node5 := &Tree{Value: 5, Children: []*Tree{node8, node9, node10, node11}}
// node4 := &Tree{Value: 4}
// node3 := &Tree{Value: 3}
// node2 := &Tree{Value: 2, Children: []*Tree{node5, node6, node7}}
// root := &Tree{Value: 1, Children: []*Tree{node2, node3, node4}}
// levelTreeOrder(root)
// -----------二叉树-----------------
// node7 := &BinaryTree{Value: 7}
// node6 := &BinaryTree{Value: 6}
// node5 := &BinaryTree{Value: 5}
// node4 := &BinaryTree{Value: 4}
// node3 := &BinaryTree{Value: 3, Left: node6, Right: node7}
// node2 := &BinaryTree{Value: 2, Left: node4, Right: node5}
// root := &BinaryTree{Value: 1, Left: node2, Right: node3}
// fmt.Println(preOrderToStr(root))
// ---------二叉树前序遍历（递归、非递归）
// preOrderRecur(root)
// fmt.Println()
// preOrder(root)
// ---------二叉树中序遍历（递归、非递归）
// inOrderRecu(root)
// fmt.Println()
// inOrder(root)
// ---------二叉树后序遍历（递归、非递归）
// posOrderRecu(root)
// fmt.Println()
// postOrder(root)
// ---------二叉树层次遍历（打印行号）
// levelOrder(root)
// queue := MyQueue{List: list.New()}
// queue.push(1)
// queue.push(2)
// queue.push(3)
// fmt.Println(queue.pop())
// fmt.Println(queue.pop())
// fmt.Println(queue.pop())
// fmt.Println(queue.pop())
// fmt.Println(root)
// stack := MyStack{List: list.New()}
// stack.push(1)
// stack.push(2)
// stack.push(3)
// fmt.Println(stack.pop())
// fmt.Println(stack.pop())
// fmt.Println(stack.pop())
// fmt.Println(stack.pop())
}