数据结构C++——二叉树的遍历（递归和非递归）及一些简单操作

最新推荐文章于 2024-05-15 00:15:33 发布
最新推荐文章于 2024-05-15 00:15:33 发布
阅读量4.2k 收藏 19
点赞数 6
分类专栏： 数据结构与算法分析 文章标签： 数据结构 算法 二叉树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54162207/article/details/117384595
版权

数据结构C++——二叉树

文章目录

一、前言

树的遍历操作需要和栈相结合，虽然C++中有许多关于数据结构的头文件可以直接拿来使用，但对于数据结构的初学者，栈的常见操作、基本原理、代码实现都应该了熟于心。
关于数据结构——栈的文章：链接: 数据结构与算法分析（C++）——栈.

二、二叉树的一些常见操作

①二叉树的存储结构

二叉树的顺序存储表示

/*-------二叉树的顺序存储表示------*/
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef TElemType SqBiTree[MAXSIZE];
SqBiTree bt;

二叉树的二叉链表存储表示


/*-------二叉树的二叉链表存储表示------*/
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef int Status;
typedef char TElemType;//定义树结点的数据类型
typedef struct BiTNode {
	TElemType data;//结点数据域
	struct BiTNode* lchild, * rchild;//结点指针域
	bool isFirst;//非递归的后序遍历用来判断某结点是否第一次出现在栈顶
}BiTNode,*BiTree;

②二叉树的先序遍历

先序遍历的递归算法

先序遍历的递归算法思路：
1：访问根结点
2：先序遍历左子树
3：先序遍历右子树

/*-------先序遍历二叉树T的递归算法---------*/
void InOrderTraverse011(BiTree T) {
	//先序遍历的递归算法
	if (T) {
		cout << T->data;//访问根结点
		InOrderTraverse011(T->lchild);//先序遍历左子树
		InOrderTraverse011(T->rchild);//先序遍历右子树
	}
}

先序遍历的非递归算法

先序遍历的非递归算法思路：
1：从根结点开始，先访问根结点，输出根结点的数据域的值
2：将根结点压入栈，以便于后续弹栈遍历右子树
3：遍历左子树且不断输出子树根结点，并将结点压入栈
4：从栈顶弹出无左子树的结点，开始遍历右子树

/*------先序遍历二叉树T的非递归算法------*/
void InOrderTraverse012(BiTree T) {
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//q指针用于接收出栈元素
	while (p || !StackEmpty(S)) {
		if (p) {
			cout << p->data;//访问根结点
			Push(S, p);//根指针进栈
			p = p->lchild;//遍历左子树
		}
		else {
			Pop(S, q);//退栈
			p = q->rchild;//遍历右子树
		}
	}
}

③二叉树的中序遍历

中序遍历的递归算法

中序遍历的递归算法思路：
1：中序遍历左子树
2：访问根结点
3：中序遍历右子树

/*-------中序遍历的递归算法---------*/
void InOrderTraverse001(BiTree T) {
	//中序遍历二叉树T的递归算法
	if (T)
	{
		InOrderTraverse001(T->lchild);//中序遍历左子树
		cout << T->data;//访问根节点
		InOrderTraverse001(T->rchild);//中序遍历右子树
	}
}

中序遍历的非递归算法

中序遍历的非递归算法思路：
1：从根结点开始，遇到结点则将结点压栈
2：当遇到无左子树的结点时，将此结点弹栈且访问它并遍历它的右子树
3：若该结点为叶子结点，则继续弹栈，开始遍历它的父节点的右子树

/*-------中序遍历的非递归算法---------*/
void InOrderTraverse002(BiTree T) {
	//中序遍历二叉树T的非递归算法
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//q指针用于接收出栈元素
	while (p || !StackEmpty(S)) {
		if (p) {//p非空
			Push(S, p);//根指针进栈
			p = p->lchild;//遍历左子树
		}
		else {
			Pop(S, q);//退栈
			cout << q->data;//访问根结点
			p = q->rchild;//遍历右子树
		}
	}
}

④二叉树的后序遍历

后序遍历的递归算法

后序遍历的递归算法思路：
1：后序遍历左子树
2：后序遍历右子树
3：访问根结点

/*-------后序遍历二叉树T的递归算法-------*/
void InOrderTraverse021(BiTree T) {
	if (T) {
		InOrderTraverse021(T->lchild);//后序遍历左子树
		InOrderTraverse021(T->rchild);//后序遍历右子树
		cout << T->data;//访问根结点
	}
}

后序遍历的非递归算法

后序遍历的非递归算法思路：
1：从根结点开始，沿其左子树一直往下搜索且压栈，直至出现没有左子树的结点
2：将此结点的isFirst域置为true，表面该结点第一次出现在栈顶
3：取栈顶元素并弹栈，若该栈顶元素第一次出现在栈顶则压栈，并将其isFirst域置为false，开始遍历右子树
4：若该栈顶元素第二次出现在栈顶则访问该结点，并将p指针置空以便继续弹栈，操作其父节点。

/*------后序遍历二叉树T的非递归算法-------*/
void InOrderTraverse022(BiTree T) {
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//出栈时接收栈顶元素
	BiTNode* t = new BiTNode;//接收栈顶元素
	while (p || !StackEmpty(S)) {
		while (p)//沿左子树一直往下搜索，直至出现没有左子树的结点
		{
			Push(S, p);
			p->isFirst = true;//此时结点均是第一次成为栈顶元素
			p = p->lchild;//遍历左子树
		}
		if (!StackEmpty(S))
		{
			t = GetTop(S);//取栈顶元素
			Pop(S, q);//出栈
			if (t->isFirst == true) {//若t为第一次出现在栈顶元素
				Push(S, q);
				t->isFirst = false;
				p = q->rchild;//遍历栈顶元素的右子树
			}
			else
			{//此时t为第二次出现在栈顶元素了
				cout << t->data;//访问栈顶元素
				p = NULL;//将指针置空
			}
		}
	}
}

⑤复制二叉树

复制二叉树。

/*-----------复制二叉树-------------*/
void Copy(BiTree T, BiTree& NewT) {
	//复制一颗和T完全相同的二叉树
	if (T == NULL) {//如果是空栈，递归结束
		NewT = NULL;
		return;
	}
	else {
		NewT = new BiTNode;
		NewT->data = T->data;//复制根结点
		Copy(T->lchild, NewT->lchild);//递归复制左子树
		Copy(T->rchild, NewT->rchild);//递归复制右子树
	}
}

⑤计算二叉树的深度

计算二叉树的深度。

/*----------计算二叉树的深度-----------*/
int Depth(BiTree T) {
	//计算二叉树T的深度
	if (T == NULL) return 0;//如果是空树，深度为0，递归结束
	else {
		int m, n;
		m = Depth(T->lchild);//递归计算左子树的深度记为m
		n = Depth(T->rchild);//递归计算右子树的深度记为n
		if (m > n) return (m + 1);//二叉树的深度为m与n的较大者加1
		else return (n + 1);
	}
}

⑥统计二叉树中结点的个数

统计二叉树中结点的个数。

/*------------统计二叉树中结点的个数-------------*/
int NodeCount(BiTree T) {
	//统计二叉树T中结点的个数
	if (T == NULL) return 0;//如果是空树，则结点个数为0，递归结束
	else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
	//否则结点个数为左子树的结点个数+右子树的结点个数+1
}

----------------------------------一道华丽的分割线---------------------------------

三、完整代码

操作二叉树的完整代码（含main函数）。

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef int Status;
typedef char TElemType;//定义树结点的数据类型


/*-------二叉树的二叉链表存储表示------*/
typedef struct BiTNode {
	TElemType data;//结点数据域
	struct BiTNode* lchild, * rchild;//结点指针域
	bool isFirst;//非递归的后序遍历用来判断某结点是否第一次出现在栈顶
}BiTNode,*BiTree;
typedef BiTree SElemType;
/*--------------------------------------------------------------*/
/*----------栈的存储结构-----------*/
typedef struct SqStack {
	SElemType data;//结点数据域
	struct SqStack* next;//结点的指针域
}StackNode, * LinkStack;
/*---------栈的初始化-------------*/
Status InitStack(LinkStack& S) {
	//栈的初始化
	S = NULL;
	return OK;
}
/*---------判断是否栈空-----------*/
Status StackEmpty(LinkStack& S) {
	if (S == NULL) return OK;
	return ERROR;
}
/*---------链栈的入栈------------*/
Status Push(LinkStack& S, SElemType e) {
	StackNode* p = new StackNode;
	p->data = e;
	p->next = S;
	S = p;
	return OK;
}
/*--------链栈的出栈------------*/
Status Pop(LinkStack& S, SElemType& e) {
	if (S == NULL) return ERROR;
	e = S->data;
	StackNode* p = new StackNode;
	p = S;
	S = S->next;
	delete p;
	return OK;
}
/*---------链栈的取栈顶元素------------*/
SElemType GetTop(LinkStack& S) {
	if (S!=NULL)
	{
		return S->data;
	}
}
/*---------------------------------------------------------------*/


/*-------中序遍历的递归算法---------*/
void InOrderTraverse001(BiTree T) {
	//中序遍历二叉树T的递归算法
	if (T)
	{
		InOrderTraverse001(T->lchild);//中序遍历左子树
		cout << T->data;//访问根节点
		InOrderTraverse001(T->rchild);//中序遍历右子树
	}
}
/*-------中序遍历二叉树T的非递归算法-------*/
void InOrderTraverse002(BiTree T) {
	//中序遍历二叉树T的非递归算法
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//q指针用于接收出栈元素
	while (p || !StackEmpty(S)) {
		if (p) {//p非空
			Push(S, p);//根指针进栈
			p = p->lchild;//遍历左子树
		}
		else {
			Pop(S, q);//退栈
			cout << q->data;//访问根结点
			p = q->rchild;//遍历右子树
		}
	}
}

/*-------先序遍历二叉树T的递归算法---------*/
void InOrderTraverse011(BiTree T) {
	//先序遍历的递归算法
	if (T) {
		cout << T->data;//访问根结点
		InOrderTraverse011(T->lchild);//先序遍历左子树
		InOrderTraverse011(T->rchild);//先序遍历右子树
	}
}
/*------先序遍历二叉树T的非递归算法------*/
void InOrderTraverse012(BiTree T) {
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//q指针用于接收出栈元素
	while (p || !StackEmpty(S)) {
		if (p) {
			cout << p->data;//访问根结点
			Push(S, p);//根指针进栈
			p = p->lchild;//遍历左子树
		}
		else {
			Pop(S, q);//退栈
			p = q->rchild;//遍历右子树
		}
	}
}

/*-------后序遍历二叉树T的递归算法-------*/
void InOrderTraverse021(BiTree T) {
	if (T) {
		InOrderTraverse021(T->lchild);//后序遍历左子树
		InOrderTraverse021(T->rchild);//后序遍历右子树
		cout << T->data;//访问根结点
	}
}
/*------后序遍历二叉树T的非递归算法-------*/
void InOrderTraverse022(BiTree T) {
	LinkStack S = new StackNode;//定义一个链栈
	InitStack(S);//初始化此链栈
	BiTNode* p = new BiTNode;
	p = T;
	BiTNode* q = new BiTNode;//出栈时接收栈顶元素
	BiTNode* t = new BiTNode;//接收栈顶元素
	while (p || !StackEmpty(S)) {
		while (p)//沿左子树一直往下搜索，直至出现没有左子树的结点
		{
			Push(S, p);
			p->isFirst = true;//此时结点均是第一次成为栈顶元素
			p = p->lchild;//遍历左子树
		}
		if (!StackEmpty(S))
		{
			t = GetTop(S);//取栈顶元素
			Pop(S, q);//出栈
			if (t->isFirst == true) {//若t为第一次出现在栈顶元素
				Push(S, q);
				t->isFirst = false;
				p = q->rchild;//遍历栈顶元素的右子树
			}
			else
			{//此时t为第二次出现在栈顶元素了
				cout << t->data;//访问栈顶元素
				p = NULL;//将指针置空
			}
		}
	}
}

/*------先序遍历的顺序建立二叉链表-------*/
void CreateBiTree(BiTree& T) {
	//按先序次序输入二叉树中结点的值（一个字符）、创建二叉链表表示的二叉树T
	TElemType ch;
	cin >> ch;
	if (ch == '#') T = NULL;//递归结束，建空树
	else//递归创建二叉树
	{
		T = new BiTNode;//生成根结点
		T->data = ch;//根结点数据域置为ch
		CreateBiTree(T->lchild);//递归创建左子树
		CreateBiTree(T->rchild);//递归创建右子树
	}
}
/*-----------复制二叉树-------------*/
void Copy(BiTree T, BiTree& NewT) {
	//复制一颗和T完全相同的二叉树
	if (T == NULL) {//如果是空栈，递归结束
		NewT = NULL;
		return;
	}
	else {
		NewT = new BiTNode;
		NewT->data = T->data;//复制根结点
		Copy(T->lchild, NewT->lchild);//递归复制左子树
		Copy(T->rchild, NewT->rchild);//递归复制右子树
	}
}
/*----------计算二叉树的深度-----------*/
int Depth(BiTree T) {
	//计算二叉树T的深度
	if (T == NULL) return 0;//如果是空树，深度为0，递归结束
	else {
		int m, n;
		m = Depth(T->lchild);//递归计算左子树的深度记为m
		n = Depth(T->rchild);//递归计算右子树的深度记为n
		if (m > n) return (m + 1);//二叉树的深度为m与n的较大者加1
		else return (n + 1);
	}
}
/*------------统计二叉树中结点的个数-------------*/
int NodeCount(BiTree T) {
	//统计二叉树T中结点的个数
	if (T == NULL) return 0;//如果是空树，则结点个数为0，递归结束
	else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
	//否则结点个数为左子树的结点个数+右子树的结点个数+1
}
/*-----------运行主函数------------*/
int main()
{
	BiTree T1 = new BiTNode;
	CreateBiTree(T1);
	InOrderTraverse021(T1);
	cout << endl;
	InOrderTraverse022(T1);
	//BiTree T2 = new BiTNode;
	//Copy(T1, T2);
	//InOrderTraverse022(T2);
	return 0;
}
//a#b#cdef#####
//ABC##DE#G##F###

测试结果

输入：ABC##DE#G##F###

先序遍历构建的二叉树：
在这里插入图片描述
先序遍历输出结果

输出：ABCDEGF

中序遍历输出结果

输出：CBEGDFA

后序遍历输出结果

输出：CGEFDBA

三、总结

以上为笔者对于树的简单操作的一些见解，希望初学者都能有所收获，有技术不到位的地方，还望各位大佬指正。
同时，笔者的个人主页还有数据结构中栈和队列的一些见解与分析，后续数据结构的相关知识还将陆续更新，欢迎大家访问且共同学习！

近景_
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树遍历（C++ 实现）
业精于勤，荒于嬉
03-15 375
递归遍历方式就不写了，在此写下层序遍历和非递归前序方式。 1、建立二叉树如下图所示： 2、层序遍历方式，是用BFS方法，队列实现，这种方式也很简单，见bfs_travel； 3、使用栈来模拟递归的方式，前序递归遍历方式为： void travel(TreeNode *root) { 记录root-&amp;amp;amp;gt;val; travel(root-&amp;amp;amp;gt;left); // 遍历左子树 travel...
二叉树的遍历(递归和非递归)实现 C++
JQ210245253的博客
05-22 409
1.二叉树的概念 树是一种非线性的数据结构，相对于线性的数据结构(链表、数组)而言，树的平均运行时间更短(往往与树相关的排序时间复杂度都不会高) 二叉树是一个每个最结最多只能有两个分支的树，左边的分支称之为左子树，右边的分支称之为右子树。也就是说二叉树节点的度最大也就是2，而普通的树，节点的度是没有限制的。 2.二叉树的分类 完全二叉树——若设二叉树的高度为h，除第 h 层外，...
二叉树遍历 非递归 C++实现代码
09-05
对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现
C C++最全【算法】二叉树的遍历指南(前序、中序、后序、层序，《C C++面试题及解析》分享给大家
最新发布
2401_84976377的博客
05-15 782
二叉树（Binary tree）是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。在下面这副图中，F就是这棵二叉树的根节点，其左、右孩子节点分别为C、E。前序、中序、后序遍历其实都是深度优先思想的体现，我这里采用递归写法，便于记忆，三者的区别在于：遍历左右子树与对此节点做出操作（）的顺序对比三种算法，大家可以很清晰地找到他们唯一的不同点：print()函数与两个递归的先后执行顺序。总结以下，可以发现前序遍历。
求二叉树中任意两个结点间的路径（C++）
zjq0889的博客
09-25 4379
方法一 #include &lt;iostream&gt; #include &lt;vector&gt; using namespace std; struct Node { int val; Node* left; Node* right; Node(int v) { val = v; left = nullptr; right = nullptr; } }; vo...
二叉树根结点到任意结点的路径（C语言）
wowpH
10-08 1万+
树，二叉树，遍历，结构体，数据结构，存储结构，链表，栈，链栈，路径，先序遍历，递归，DFS，图，出栈，入栈，栈顶元素，malloc，exit，push，pop，peek。
二叉树（C++模板实现）
qq_39559641的博客
04-07 4964
一、实验要求 <1>打印出二叉树的三种遍历序。 <2>设计算法按中序次序输出二叉树中各结点的值及其所对应的层次数。 <3>求二叉树的高度。 <4>求二叉树的结点数。 <5>求二叉树的叶子结点数。 <6>求二叉树的度为2的结点数。 <7>键盘输入一个...
Leetcode：257. 二叉树的所有路径（C++）
Cosmoshhhyyy的博客
01-07 566
给你一个二叉树的根节点root，按任意顺序，返回所有从根节点到叶子节点的路径。叶子节点是指没有子节点的节点。
二叉树（根节点到任意结点的路径）
weixin_45454859的博客
04-28 7665
假设二叉树采用二叉链表方式存储， root指向根结点，node 指向二叉树中的一个结点，编写函数 path，计算root到 node 之间的路径，（该路径包括root结点和 node 结点）。path 函数声明如下： bool path(BiTNode* root, BiTNode* node, Stack* s); 其中，root指向二叉树的根结点，node指向二叉树中的另一结点，s 为已经初始...
（C++）数据结构——重建二叉树（根据前序遍历与中序遍历）
~赵的博客
07-21 815
对于二叉树来说，遍历方法有前序遍历、中序遍历、后序遍历，这三种遍历方法都是相对于根节点来说的。 而我们已知一棵二叉树的中序遍历的前提下（必须已知），只要知道另外两种遍历方法的一种，我们就可以重构出这棵二叉树 这篇博客就通过一道剑指offer的一道题目来了解如何根据一棵二叉树的前序遍历与中序遍历重构这棵二叉树。不知道这两种遍历方法的请点击这里。而主要的思想就是递归，不太懂递归的请点击这里 题目描...
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历）
12-31
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历） 二叉树的性质： 二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 例： 实例代码： #include #include #include ...
二叉树遍历的c++实现（递归和非递归深度优先遍历）
09-13
深度优先遍历的实现； 广度优先遍历的实现；
C++实现二叉树非递归遍历方法实例总结
09-04
非递归遍历通常依赖于栈（stack）数据结构来模拟递归调用的过程，避免了函数调用的开销，并且可以避免深度过大的栈溢出问题。下面分别介绍如何使用非递归方式实现前序、中序和后序遍历。 1. 前序遍历（根-左-右） ...
数据结构-非递归遍历二叉树
11-16
总之，非递归遍历二叉树是数据结构中的重要概念，它涉及栈和队列等基本数据结构的操作，以及逻辑控制的巧妙运用。掌握这些技巧，不仅可以帮助我们更好地理解和应用二叉树，也有助于提升我们的算法设计能力。
c++实现二叉树并遍历
qq_43575504的博客
04-03 1030
Ⅰ 有且只有一个称为根的节点 Ⅱ 有若干个互不相交的子树，这些子树本身也是一棵树 节点、父节点、子节点、子孙、堂兄弟 深度：从根节点到最底层节点的层数，根节点是第一层 叶子节点：没有子节点的节点 非终端节点：非叶子节点 度：子节点的个数 Ⅰ 一般树木：任意一个节点的子节点个数不受限制 Ⅱ 二叉树：任意一个节点的子节点个数最多两个，且子节点位置不可更改 ① 一般二叉树
C语言/C++实现链表的详细教程
热门推荐
qq_43884946的博客
06-14 1万+
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含两部分内容：数据和指向下一个节点的指针,最后一个节点指向空。链表的节点可以动态添加和删除，因此可以方便地进行插入、删除等操作。链表有多种类型，包括单向链表、双向链表和循环链表等。
c++数据结构二叉树（二叉链表实现）基本操作实现
weixin_53144360的博客
11-11 5169
二叉树： 二叉树（Binarytree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 性质： 二叉树性质 性质1：二叉树的第i层上至多有2i-1（i≥1）个节点。 性质2：深度为h的二叉树中至多含有2h-1个节点。 性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2...
求根结点到指定结点的路径
Vmorish
02-20 8976
Description 二叉树采用二叉链表存储结构进行存储，需要输出从二叉树的树根到指定结点的完整路径。按照给出的先序序列根据教材中算法6.4所示的算法建立二叉链表。二叉树中每个结点的数据都不相同。 Input 包含多组测试数据。 每组测试数据的第一行给出二叉树的先序遍历序列（结点数至少1个，不超过100个），用于建立二叉链表存储的二叉树。 第二行一个整数m，
数据结构---二叉树路径问题
记录我目之所及的世界
01-03 691
回溯，二叉树路径
c++实现中序遍历二叉树的递归算法和非递归算法
04-18
以下是中序遍历二叉树的递归算法和非递归算法的实现代码，供您参考： 递归算法： ``` void inorder_recursive(TreeNode* root) { if (root) { inorder_recursive(root->left); cout << root->val << " "; inorder_recursive(root->right); } } ``` 非递归算法： ``` void inorder_nonrecursive(TreeNode* root) { stack<TreeNode*> stk; TreeNode* curr = root; while (curr || !stk.empty()) { while (curr) { stk.push(curr); curr = curr->left; } curr = stk.top(); stk.pop(); cout << curr->val << " "; curr = curr->right; } } ``` 请注意，这里的 `TreeNode` 结构体是二叉树节点的定义，其中包含了节点的值、左子节点和右子节点。如果您需要使用这些代码，请先自行定义 `TreeNode` 结构体。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

近景_

打赏拉满，动力满满

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值