遍历二叉树（递归，非递归都有）

最新推荐文章于 2025-05-19 00:11:36 发布
原创 最新推荐文章于 2025-05-19 00:11:36 发布 · 985 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang #二叉树 #遍历 #非递归 #递归

本文介绍二叉树的非递归遍历方法，包括先根、中根和后根遍历，并提供详细的Go语言实现代码。通过使用栈结构来辅助遍历过程，避免了递归带来的堆栈溢出风险。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

主要描述一下非递归，递归在下面的总的代码里有：

因为非递归都用到了栈，先贴一下栈的代码

const stackSize int = 22                //栈的容量

type TreeNode struct {               //树结点
	Left *TreeNode
	Value int
	Right *TreeNode
}

type Stack struct {                     //栈结构
	Size int
	Values []*TreeNode
}

func CreateStack() Stack{                //创建栈
	s := Stack{}
	s.Size = stackSize
	return s
}

func (s *Stack) IsFull() bool {          //栈满
	return len(s.Values) == s.Size
}

func (s *Stack) IsEmpty() bool {          //栈空
	return len(s.Values) == 0
}

func (s *Stack) Push(a *TreeNode) error {       //入栈
	if s.IsFull() {
		return errors.New("Stack is full,push failed")
	}
	s.Values = append(s.Values,a)
	return nil
}

func (s *Stack) Pop() (*TreeNode,error) {//出栈,并返回其值
	if s.IsEmpty() {
		return nil ,errors.New("Out of index,len(stack) is 0")
	}
	res := s.Values[len(s.Values)-1]
	s.Values = s.Values[:len(s.Values)-1]
	return res,nil
}

func (s *Stack) Peek() (*TreeNode,error) {//查看栈顶元素
	if s.IsEmpty() {
		return nil ,errors.New("Out of index,len(stack) is 0")
	}
	return s.Values[len(s.Values)-1],nil
}

一、先根遍历的非递归算法：步骤如下：

1、创建一个栈对象，将根节点入栈；

2、当栈为非空时，将栈顶结点弹出栈并访问该结点；

3、对当前访问的非空左孩子结点相继依次访问（不需要入栈），并将访问结点的非空右孩子结点入栈

4、重复执行步骤②和步骤③，直到栈为空为止

func PreStackTraverse(t *TreeNode){//先根遍历，非递归
	if t != nil {
		S := CreateStack()
		S.Push(t)
		for !S.IsEmpty() {
			T,_ := S.Pop()
			fmt.Printf("%d ",T.Value)
			for T != nil {
				if T.Left != nil {
					fmt.Printf("%d ",T.Left.Value)
				}
				if T.Right != nil {
					S.Push(T.Right)
				}
				T = T.Left
			}
		}
	}
	fmt.Println()
}

二、中根遍历的非递归算法：步骤如下：

1、创建一个栈对象，将根节点入栈；

2、当栈为非空时，将根结点的非空左孩子相继进栈；

3、栈顶结点出栈并访问栈顶结点，并使该栈顶结点的非空右孩子结点入栈

4、重复执行步骤②和步骤③，直到栈为空为止

//中根遍历，非递归
func MidStackTraverse(t *TreeNode){
	if t != nil {
		S := CreateStack()
		S.Push(t)
		for !S.IsEmpty() {
			top,_ :=S.Peek()
			for  top != nil {       //将栈顶结点的所有左孩子结点入栈
				S.Push(top.Left)
				top,_= S.Peek()
			}
			S.Pop()                //空结点退栈
			if !S.IsEmpty() {
				T,_ := S.Pop()
				fmt.Printf("%d ",T.Value)
				S.Push(T.Right)
			}
		}
	}
	fmt.Println()
}

三、后根遍历的非递归算法：

便于理解点：

flag : 当栈中加入右孩子之后，该右孩子的左孩子也要跟着加入栈中，flag为false标记加入了一个右孩子,跳出访问栈顶的循环，将该结点的左孩子加入栈中。否则flag为true，可以继续判断该栈顶 

p :  刚刚被访问的结点，当一个结点可以被访问时，要么其右孩子为空，要么p指向其右孩子

步骤如下：

1、创建一个栈对象，根节点进栈，p赋初值null；

2、若栈非空，则栈顶结点的非空左孩子相继进栈；

3、若栈非空，查看栈顶结点，若栈顶结点的右孩子为空，或与p相等，则将栈顶结点弹出栈并访问它，同时将p指向该结点，并设置flag为true。否则将栈顶结点的右孩子（1个）压入栈中，并置flag为false

4、若flag==true,重复执行3，否则，重复执行步骤2和3，直到栈为空。

//后根遍历，非递归
func PostStackTraverse(t *TreeNode) {
	if t != nil {
		S := CreateStack()
		S.Push(t)
		var flag bool
		var p *TreeNode
		for !S.IsEmpty() {
			top,_ := S.Peek()
			for  top != nil {       //将栈顶结点的所有左孩子结点入栈
				S.Push(top.Left)
				top,_= S.Peek()
			}
			S.Pop()
			for !S.IsEmpty() {
				T,_ := S.Peek()
				if T.Right == nil || T.Right == p {
					fmt.Printf("%d ",T.Value)
					S.Pop()
					flag = true
					p = T            //p指向刚被访问的结点
				}else {
					S.Push(T.Right)
					flag = false     //有右孩子进栈了
				}
				if !flag {            //退出该循环
					break
				}
			}
		}
	}
	fmt.Println()
}

完整代码：

package main

import (
	"fmt"
	"errors"
)

const stackSize int = 22                //栈的容量

type TreeNode struct {
	Left *TreeNode
	Value int
	Right *TreeNode
}

type Stack struct {                     //栈结构
	Size int
	Values []*TreeNode
}

func CreateStack() Stack{                //创建栈
	s := Stack{}
	s.Size = stackSize
	return s
}

func (s *Stack) IsFull() bool {          //栈满
	return len(s.Values) == s.Size
}

func (s *Stack) IsEmpty() bool {          //栈空
	return len(s.Values) == 0
}

func (s *Stack) Push(a *TreeNode) error {       //入栈
	if s.IsFull() {
		return errors.New("Stack is full,push failed")
	}
	s.Values = append(s.Values,a)
	return nil
}

func (s *Stack) Pop() (*TreeNode,error) {//出栈,并返回其值
	if s.IsEmpty() {
		return nil ,errors.New("Out of index,len(stack) is 0")
	}
	res := s.Values[len(s.Values)-1]
	s.Values = s.Values[:len(s.Values)-1]
	return res,nil
}

func (s *Stack) Peek() (*TreeNode,error) {//查看栈顶元素
	if s.IsEmpty() {
		return nil ,errors.New("Out of index,len(stack) is 0")
	}
	return s.Values[len(s.Values)-1],nil
}

func (s *Stack) Traverse() {
	if s.IsEmpty() {
		fmt.Println("Stack is empty")
	}else {
		fmt.Println(s.Values)
	}
}

//建立二叉树
func TreeCreate(i int,arr []int) *TreeNode{
	t := &TreeNode{nil,arr[i],nil}
	if i<len(arr) && 2*i+1 < len(arr){
		t.Left = TreeCreate(2*i+1,arr)
	}
	if i<len(arr) && 2*i+2 < len(arr) {
		t.Right = TreeCreate(2*i+2,arr)
	}
	return t
}

//先根遍历，递归
func PreTraverse(t *TreeNode){
	if t != nil {
		fmt.Printf("%d/",t.Value)
		PreTraverse(t.Left)
		PreTraverse(t.Right)
	}
}

//先根遍历，非递归
func PreStackTraverse(t *TreeNode){
	if t != nil {
		S := CreateStack()
		S.Push(t)                               //根结点入栈
		for !S.IsEmpty() {
			T,_ := S.Pop()                      //移除根结点，并返回其值
			fmt.Printf("%d ",T.Value)    //访问结点
			for T != nil {
				if T.Left != nil {              //访问左孩子
					fmt.Printf("%d ",T.Left.Value)   //访问结点
				}
				if T.Right != nil {              //右孩子非空入栈
					S.Push(T.Right)
				}
				T = T.Left
			}
		}
	}
	fmt.Println()
}

//中根遍历，递归
func MidTraverse(t *TreeNode){
	if t != nil {
		MidTraverse(t.Left)
		fmt.Printf("%d/",t.Value)
		MidTraverse(t.Right)
	}
}

//中根遍历，非递归
func MidStackTraverse(t *TreeNode){
	if t != nil {
		S := CreateStack()
		S.Push(t)
		for !S.IsEmpty() {
			top,_ :=S.Peek()
			for  top != nil {       //将栈顶结点的所有左孩子结点入栈
				S.Push(top.Left)
				top,_= S.Peek()
			}
			S.Pop()                //空结点退栈
			if !S.IsEmpty() {
				T,_ := S.Pop()
				fmt.Printf("%d ",T.Value)
				S.Push(T.Right)
			}
		}
	}
	fmt.Println()
}

//后根遍历，递归
func PostTraverse(t *TreeNode){
	if t != nil {
		PostTraverse(t.Left)
		PostTraverse(t.Right)
		fmt.Printf("%d/",t.Value)
	}
}

//后根遍历，非递归
func PostStackTraverse(t *TreeNode) {
	if t != nil {
		S := CreateStack()
		S.Push(t)
		var flag bool
		var p *TreeNode
		for !S.IsEmpty() {
			top,_ := S.Peek()
			for  top != nil {       //将栈顶结点的所有左孩子结点入栈
				S.Push(top.Left)
				top,_= S.Peek()
			}
			S.Pop()
			for !S.IsEmpty() {
				T,_ := S.Peek()
				if T.Right == nil || T.Right == p {
					fmt.Printf("%d ",T.Value)
					S.Pop()
					flag = true
					p = T            //p指向刚被访问的结点
				}else {
					S.Push(T.Right)
					flag = false     //有右孩子进栈了
				}
				if !flag {            //退出该循环
					break
				}
			}
		}
	}
	fmt.Println()
}


func main(){
	arr := []int{3,9,6,8,7,11,1,22,21}
	Tree := TreeCreate(0,arr)

    fmt.Print("前根,递归:")
	PreTraverse(Tree)
	fmt.Print("   前根,非递归:")
	PreStackTraverse(Tree)

	fmt.Print("中根,递归:")
	MidTraverse(Tree)
	fmt.Print("   中根,非递归:")
	MidStackTraverse(Tree)

	fmt.Print("后根,递归:")
	PostTraverse(Tree)
	fmt.Print("   后根,非递归:")
	PostStackTraverse(Tree)
}


Golang以OO的方式实现二叉查找树
闷骚的Gopher
04-12 5971
二叉查找树是一种满足如下性质的二叉树： (1)  某个节点的左子树中的所有节点的值都比这个节点的值小 (2)  某个节点的右子树中的所有节点的值都比这个节点的值大 下面有Go实现的非常详尽的代码，采用了Go风格的OO进行了封装。代码中主函数的例子的参照图如下： 实现代码： package main import ( "fmt" ) type TreeNode
二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历
09-09
/*********************************************************** ***********************************************************/ #include #include #include #define MS 50 struct BTreeNode ...
数据结构 二叉树的遍历（go实现）
qq_51535737的博客
03-11 521
定义：二叉树是指树中节点的度不大于2（只能0、1、2）的有序树 如下图就是一个二叉树： 下面是关于二叉树遍历的代码实现。 定义二叉树 type TreeNode struct { Val int Left *TreeNode Right *TreeNode } 遍历二叉树 遍历二叉树有四种方式： 先序遍历：先访问跟根节点，再访问左子树，最后访问右子树 中序遍历：先访问跟左子树，再访问根节点，最后访问右子树 后序遍历：先访问跟左子树，再访问右子树，最后访问根节点 层次遍历：每一层从左到右访问每一个
【数据结构 -- 二叉搜索树（BST）】用golang实现二叉搜索树
最新发布
2401_87046050的博客
05-19 924
二叉搜索树的概念、性质及实现方法（golang版）
golang 二叉树的遍历
weixin_44540711的博客
11-11 356
二叉树的便利 package main import "fmt" //二叉树的遍历 //二叉树的遍历分为三种情况，前序遍历、中序遍历、后去遍历 //定义二叉树 type Node struct { Id int Name string Left *Node Right *Node } //前序遍历 func (this *Node)PreOrder(node *Node) { if node != nil{ fmt.Println(node.Name) this.PreOrd.
Go遍历二叉树
稻草人技术博客
04-08 411
package main import "fmt" type Node struct { Val int Left *Node Right *Node } // 1 // / \ // 2 3 // / \ / \ // 4 5 6 7 func main() { head := &No...
二叉树遍历——中序遍历（Golang）
皮埃尔的博客
02-14 1189
二叉树遍历——中序遍历
先序遍历二叉树的递归实现与非递归实现深入解析
12-26
1、先序遍历二叉树 递归实现思想：若二叉树为空，返回。否则 1）遍历根节点；2）先序遍历左子树；3）先序遍历右子树； 代码： 代码如下:template<typename> void PreOrder(nodeType<elemType> *root) { if(root==...
遍历二叉树的4个非递归算法.rar_binary tree_二叉树_二叉树 非递归 遍历_递归_遍历 CSharp
09-14
在IT领域，特别是数据结构的学习中，二叉树是一种基础且重要的概念。它是由节点（包含数据和两个指向其他节点的引用）...因此，"遍历二叉树的4个非递归算法"这个资源对于数据结构和算法的学习者来说是十分有价值的。
遍历二叉树递归+非递归实验报告.doc
10-10
本文将围绕“遍历二叉树递归+非递归实验报告”这一主题，深入探讨二叉树的构造特征、遍历方法，以及递归与非递归遍历的实现和区别。 首先，二叉树作为树形数据结构的一种，其节点最多有两个子节点，分别称为左子...
Golang 二叉树遍历
不要因为走的太远而忘了为什么出发
04-09 1000
文章目录1. 二叉树的定义2. 前序遍历3. 中序遍历4. 后序遍历 1. 二叉树的定义 二叉树需满足的条件 ① 本身是有序树 ② 树中包含的各个节点的长度不能超过2，即只能是0、1或者2 2. 前序遍历 前序遍历二叉树的顺序：根——》左——》右 package main import "fmt" //定义结构体 type Student struct { Name string Age int Score float32 left *Student //左子树指针 righ
go语言实现二叉树遍历
weixin_43318506的博客
07-04 805
代码如下 package main import ( "fmt" ) type Node struct { Value string Left, Right *Node } func (node *Node) Print() { fmt.Print(node.Value, " ") } func (node *Node) SetValue(v string) { if node == nil { fmt.Println("setting value to nil.node
golang数据结构二叉树遍历
qq_54129105的博客
04-26 910
golang数据结构二叉树算法遍历
Go 二叉树递归遍历输出（前序、中序、后序）
weixin_45743893的博客
02-17 446
Go 二叉树递归遍历输出（前序、中序、后序） 前序遍历：根结点 —> 左子树 —> 右子树 中序遍历：左子树—> 根结点 —> 右子树 后序遍历：左子树 —> 右子树 —> 根结点 树结构体 type TreeNode struct { Val int //值 Left *TreeNode //左子树指针 Right *TreeNode //右子树指针 } 前序（深度优先遍历） func kthLargest(root *TreeNode) {
【golang】二叉树的遍历
codeman_cdb的专栏
03-07 1049
1） 访问根节点；2） 先序遍历左子树；3） 先序遍历右子树。
使用golang实现二叉树,并且遍历
qq_32535455的博客
01-14 924
什么是二叉树：每个节点最多只有两个儿子节点的树 满二叉树：叶子节点与叶子节点之间的高度差为 0 的二叉树，即整棵树是满的，树呈满三角形结构。在国外的定义，非叶子节点儿子都是满的树就是满二叉树。 完全二叉树：完全二叉树是由满二叉树而引出来的，设二叉树的深度为 k，除第 k 层外，其他各层的节点数都达到最大值，且第 k 层所有的节点都连续集中在最左边。 使用Go语言定义: type TreeNode struct { Data string // 节点用来存放数据 Left *Tr.
二叉树中序遍历（非递归非栈法 Golang版）
晨猫
10-20 269
package main import ( "fmt" ) type TreeNode struct { value int left *TreeNode right *TreeNode } func addNode(head *TreeNode, value int) *TreeNode { if head == nil { return &TreeNode{value, nil, nil} } else if (value >= head.value) { he
Golang二叉树的4种遍历方式（先序，中序，后序，层序）
Lyon_Nee的博客
07-28 3607
本文只涉及使用Golang实现的（普通）二叉树的先序、中序、后序和层序的递归遍历方式。 二叉树 树的任意节点至多包含两棵子树。 二叉树的遍历 二叉树的遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。 题目数据 我们以上面的这个二叉树图为基础数据编写代码 Code 基础结构 二叉树需要存储自身节点数据，以及最多两个子节点的索引 type BinaryTree struct { Value int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值