golang 遍历list_golang之树的遍历

go语言在区块链编程中有巨大的优势，其中fabric和ethereum都是基于go语言编写的。为了能更好的学习区块链的底层技术，先将go的基础打好。

本篇文章使用golang来实现树的遍历

树的定义

package tree

type Node struct {

Val int

Left *Node

Right *Node

}

深度优先遍历

深度优先遍历需要优先使用栈

栈的定义

type Stack struct {

list *list.List

}

func NewStack() *Stack {

list := list.New()

return &Stack{list}

}

func (stack *Stack) Push(value interface{}) {

stack.list.PushBack(value)

}

func (stack *Stack) Pop() interface{} {

if e := stack.list.Back(); e!= nil {

stack.list.Remove(e)

return e.Value

}

return nil

}

func (stack *Stack) Len() int {

return stack.list.Len()

}

func (stack *Stack) Empty() bool {

return stack.Len() == 0

}

前序遍历

为Stack结构体添加前序遍历的方法，前序遍历的思路是通过栈，将右子树先行压栈，然后左子树压栈

func (root *Node) PreTravesal() {

if root == nil {

return

}

s := stack.NewStack()

s.push(root)

for !s.Empty() {

cur := s.Pop().(*Node)

fmt.Println(cur.Val)

if cur.Right != nil {

s.Push(cur.Right)

}

if cur.Left != nil {

s.Push(cur.Left)

}

}

}

中序遍历

func (root *Node) InTravesal() {

if root == nil {

return

}

s := stack.NewStack()

cur := root

for {

for cur != nil {

s.Push(cur)

cur = cur.Left

}

if s.Empty() {

break

}

cur = s.Pop().(*Node)

fmt.Println(cur.Val)

cur = cur.right

}

}

后序遍历

func (root *Node) PostTravesal() {

if root == nil {

return

}

s := stack.NewStack()

out := stack.NewStack()

s.Push(root)

for !s.Empty() {

cur := s.Pop().(*Node)

out.Push(cur)

if cur.Left != nil {

s.Push(cur.Left)

}

if cur.Right != nil {

s.Push(cur.Right)

}

}

for !out.Empty() {

cur := out.Pop().(*Node)

fmt.Println(cur.Val)

}

}

广度优先遍历

广度优先遍历需要使用到队列

实现队列

使用切片实现队列

package queue

import (

"fmt"

)

type Queue interface {

Offer(e interface{})

Poll() interface{}

Clear() bool

Size() int

IsEmpty() bool

}

type LinkedList struct {

elements []interface{}

}

func New() *LinkedList {

return &LinkedList{}

}

func (queue *LinkedList) Offer(e interface{}) {

queue.elements = append(queue.elements, e)

}

func (queue *LinkedList) Poll() interface{} {

if queue.IsEmpty() {

fmt.Println("Poll error : queue is Empty")

return nil

}

firstElement := queue.elements[0]

queue.elements = queue.elements[1:]

return firstElement

}

func (queue *LinkedList) Size() int {

return len(queue.elements)

}

func (queue *LinkedList) IsEmpty() bool {

return len(queue.elements) == 0

}

func (queue *LinkedList) Clear() bool {

if queue.IsEmpty() {

fmt.Println("queue is Empty!")

return false

}

for i := 0; i < queue.Size(); i++ {

queue.elements[i] = nil

}

queue.elements = nil

return true

}

层序遍历

func (root *Node) LevelTravesal() {

if root == nil {

return

}

linkedList := queue.New()

linkedList.Offer(root)

for !linkedList.IsEmpty() {

cur := linkedList.Poll().(*Node)

fmt.Println(cur.Val)

if cur.Left != nil {

linkedList.Offer(cur.Left)

}

if cur.Right != nil {

linkedList.Offer(cur.Right)

}

}

}

有疑问加站长微信联系(非本文作者)