二叉树的性质创建以及四种遍历方法（递归型与非递归型）

已于 2023-04-27 14:30:03 修改
阅读量712 收藏 3
点赞数
分类专栏： 学习错误以及解决日志 文章标签： 算法 c++ 数据结构 b树
于 2023-04-25 14:43:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51264201/article/details/130342257
版权

文章目录

二叉树

性质

二叉树（Binary Tree）是一种树型结构，特点是每个节点至多只有两个子树，并且，二叉树的子树有左右之分，次序不能任意颠倒。

性质：

//--二叉树的性质--//
/*
1.每一结点最大度为2，则在第n层，最大结点数为：2^(n-1)。
2.从1到n层的总结点数最大为2^n-1。
3.度为2的结点数n2，与末端结点数n0的关系为：n0=n2+1;
a. n=n0+n1+n2;
b. n=B(连接结点的分支的总数)+1=n1+2n2+1;
 
//--满二叉树：每一层的结点数都为最大结点数。
//--完全二叉树：在末端层从已有的最右端的叶子结点像右补齐缺省的叶子节点就变为满二叉树。

 4.具有n个结点的完全二叉树的深度为[log2n]+1;
   2^(k-1)<=n<2^k;
   则可以得到k=[log2n]+1。其中k为整数，需要取整，深度即是层数。

*/

创建

构成二叉树的基本结构

结点结构：

//链式储存结构
typedef struct BiTNode
{
	int data;
	struct BiTNode* lchild, * rchild;
	//左右孩子指针。
}BiTNode,*BTree;

其中，typedef 关键字的作用：
BiTNode 结构的别名: BiTNode。
BiTNode* 结构指针的别名：BTree。

二叉树通过多个链式结构链接成树，即，通过指向结点结构的指针构建二叉树。
故， 使用结构体指针的引用 （BTree & T）作为根结点，即创建函数的形参，向下创建二叉树。

创建函数

通过类似于先序遍历的方法，将字符串里的字符挨个输入到叶子结点中。

//还是得要一个参数
bool CreateBT(BTree&T)
{
	char ch;
	ch = getchar();
	if (ch == ' ') T = NULL;
	else
	{
		//如果无法分配内存，则报错返回
		//if(!(T=new BiTnode))
		if (!(T = (BiTNode*)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		//在当前结点储存当前值，然后向下递归
		
		//将char转化为相应的int
		T->data = ch;
		//向左边递归调用直至遇到空字符
		CreateBT(T->lchild);
		CreateBT(T->rchild);
	}
	return true;
}

遍历方法

遍历结果的输出函数：（代码较短，使用内联函数）

//输出函数
inline bool BT_visit(char e)
{
	std::cout << e << std::endl;
	return true;
};

递归型

使用函数指针

    函数指针是指向函数的指针，将函数指针作为另一个函数的参数。
    与直接调用另一函数相比，稍微笨拙，但可以做到在不同时间使用不同的函数。
    函数指针指向的这些函数的返回值以及特征标相同。

函数原型（函数指针为输出函数）：

//先序遍历二叉树
bool PreOrderTraverse(const BTree T, bool (*pf)(char));

//中序遍历二叉树
bool InOrderTraverse(const BTree T, bool (*pf)(char));

//后序遍历二叉树
bool PostOrderTraverse(const BTree T, bool (*pf)(char));

可以注意到的是：
递归型的先序遍历，中序遍历，后序遍历的程序代码类型相似，不同点就是遍历的 输出函数所在的位置 。

先序中序后序
输出函数位置前中后
先序遍历：
bool PreOrderTraverse(const BTree T, bool (*pf)(char))
{
	//根结点以及末端叶子结点的非NULL判断
	if (T != NULL)
	{
		if (BT_visit(T->data))
			//递归调用，展开为不断向下的循环
			if (PreOrderTraverse(T->lchild, BT_visit))
				if (PreOrderTraverse(T->rchild, BT_visit))
					return true;
		//无法输出则返回false。
		return false;
	}
	//还是返回true，其实就是NULL时提前结束程序返回上一级
	else
	{
		//std::cout << "#";
		return true;
	}
}
中序遍历：
bool InOrderTraverse(const BTree T, bool(*pf)(char))
{
	if (T != NULL)
	{
		if (InOrderTraverse(T->lchild, BT_visit))
			if (BT_visit(T->data))
				if (InOrderTraverse(T->rchild, BT_visit))
					return true;
		return false;
	}
	else
		return true;
}
后序遍历：
//后序遍历二叉树
bool PostOrderTraverse(const BTree T, bool (*pf)(char))
{
	if (T != NULL)
	{
		if (PostOrderTraverse(T->lchild, BT_visit))
			if (PostOrderTraverse(T->rchild, BT_visit))
				if (BT_visit(T->data))
					return true;
		return false;
	}
	else
		return true;
}

不使用函数指针

相比于使用函数指针，不是用函数指针明显更简便。

前序遍历：
void PreOrderTraverse(const BTree T)
{
	if (T != NULL)
	{
		//输出当前结点储存值
		BT_visit(T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
	else
	{
		//std::cout << "#";
		return;
	}
}
中序遍历：
void InOrderTraverse(const BTree T)
{

	if (T != NULL)
	{
		//到达左结点的末端叶子结点后再向上返回。
		InOrderTraverse(T->lchild);
		//输出当前结点的值
		BT_visit(T->data);
		//进入右结点 然后重复 到最左结点输出，再向上。
		InOrderTraverse(T->rchild);
	}
	//到达末尾结点NULL时结束
	else
		return;
}
后序遍历：
void PostOrderTraverse(const BTree T)
{
	if (T != NULL)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		BT_visit(T->data);
	}
}

非递归型

二叉树不采用上述三种递归方法遍历，而采用循环遍历二叉树，就为二叉树的非递归遍历。
但，递归法通过不断向下创建下级函数以及末端结束后返回上一级函数，变相的记录了每一个结点的遍历顺序。
如果使用非递归方法，则需要一个能记录并更新结点的工具。
因此，需要使用到栈。

创建栈

注意点：栈里的BTree* 是指向结构指针的指针((BiTNode)*)*。

typedef struct stack
{
	//储存指针
	BTree* Base;
	BTree* Top;
	int stacksize;
}Sq;

创建类

   这里为可能用到的类方法。（由于博主使用类，析构类时会出现内存泄漏）
   但非递归方法是正确的，所以建议不用类方法，直接创造函数即可。

//对储存树节点的栈实行的操作
class Sqstack
{
private:
	static const int MAXSIZE = 20;
	Sq _stack;
public:
	Sqstack();
	~Sqstack();
	//结点入栈
	void Push(const BTree T);
	//判断栈是否为空
	bool Is_empty();
	//栈顶元素脱出
	BTree Pop();
	//得到栈顶元素
	BTree GetTop();
	//
};

实现方法：

Sqstack::Sqstack()
{
	//栈底
	_stack.Base = new BTree;
	_stack.Top = _stack.Base;
	_stack.stacksize = 0;
}

Sqstack::~Sqstack() 
{
	while (_stack.stacksize != 0)
	{
		delete (_stack.Top--);
		_stack.stacksize--;
	}
//	delete _stack.Base;
	BTree* pf = _stack.Base;
	_stack.Top=_stack.Base = NULL;

	delete (*(pf))->lchild;
	delete (*(pf))->rchild;
	delete pf;
};

void Sqstack::Push(const BTree T)
{
	if (_stack.stacksize >= MAXSIZE)
	{
		_stack.Base = (BTree*)realloc(_stack.Base, (_stack.stacksize + MAXSIZE) * sizeof(BTree));
		if (!_stack.Base)
			exit(OVERFLOW);
	}
	*_stack.Top++ = T;
	_stack.stacksize++;
}

bool Sqstack::Is_empty()
{
	//return _stack.Top==_stack.Base;
	 return _stack.stacksize == 0;
}

BTree Sqstack::Pop()
{

	if (Is_empty())
	{
		return *_stack.Base;

	}
	_stack.stacksize--;
	return *(--_stack.Top);
}

BTree Sqstack::GetTop()
{
	//如果栈为空栈,则返回值为
	if (Is_empty())
	{
		return *_stack.Base;
	}
	return *(_stack.Top - 1);
}

前序遍历

注：前序遍历和中序遍历都是左子树到结点到右子树的顺序，只是输出函数所在位置不同。
用栈储存从根到叶的各个结点后，对栈顶进行操作。
栈储存值规律为： 储存根走到最左的所有结点，回退到上一级结点，结点向右子树一步，不存在就回退上一级结点，继续上述操作。存在就将该节点进入栈顶端，然后向左到最左末端。
简便说就是：到达左末，回退一级，找右一步，到达左末，回退一级。如果右不存在，回退，直到右子树存在。
最后时刻栈底元素是最底层最右端的叶子结点。

void PreOrderTraverse_FD(const BTree T)
{
	using namespace std;
	if (T == NULL)
		return;
	//移动指针
	BTree pt = T;
	//创建栈储存树结点
	Sqstack temp;
	while (!temp.Is_empty() || pt != NULL)
	{
		//当走到末端，返回上一结点，开启右子树，右子树为NULL则继续退回
		while (pt != NULL)
		{
			//输出值
			//cout << pt->data;
			BT_visit(pt->data);
			//用栈储存一个值（从根到叶子的所有结点，方便回退）
			temp.Push(pt);
			//左子树
			pt = pt->lchild;
		}
		//到达这个判断式时，左子树到达了末端
		if (!temp.Is_empty())
		{
			//得到栈顶储存的指针（该指针为树结点）
			//此结点的左子树为NULL，借由此节点进入它的右子树
			pt = temp.GetTop();
			temp.Pop();
			pt = pt->rchild;
		}
	}
	delete pt;
}

中序遍历

void InOrderTraverse_FD(const BTree T)
{
	using namespace std;
	if (T == NULL)
		return;
	BTree pt = T;
	Sqstack temp;
	while (!temp.Is_empty() || pt!=NULL)
	{
		while (pt != NULL)
		{
			temp.Push(pt);
			//左子树递归
			pt=pt->lchild;
		}
		//逐渐返回根结点
		if (!temp.Is_empty())
		{
			//
			pt = temp.GetTop();
			temp.Pop();
			//可替换为pt=temp.Pop();
			//输出
			//cout << pt->data;
			BT_visit(pt->data);
			//右
			pt = pt->rchild;
		}
	}
	delete pt;
}

后序遍历

后序遍历： 由于后序遍历的输出结果为左 右 根。
因此，最后，要由右端结点返回根，即最后时刻栈底元素为根结点储存元素。
在第一个while循环里，访问到了最左末端叶子的左扩充子树NULL。
在第二个while循环的while循环中，如果能进入右子树就按照右一左尽的方式，把所有左子树输出。
最后根据访问过的判断逐渐从栈中回退并输出父亲结点。这一步理解很关键，试想当结点到达某一最右末端时，左右子树为空，因此输出结点值后，用PRef记录当前结点，在第二个while（外部循环）中，它会返回上一次结点，然后由于PRef为上一结点（此时的pf）的右子树，因此判断继续，如此重复步骤，直至返回到跟结点。

//后序遍历二叉树，非递归方法
void PostOrderTraverse_FD(const BTree T)
{
	if (T == NULL)
		return;
	BTree pf, Prepf;
	pf = T; 
	Prepf = NULL;
	Sqstack temp;
	//先直接到达左子树末端
	while (pf != NULL)
	{
		temp.Push(pf);
		pf = pf->lchild;
	}

	while (!temp.Is_empty())
	{
		//返回上一级进行判断，因为已经进入了末端的扩展NULL
		pf=temp.Pop();
		//结点右子树为0或者右子树已经访问过，第一次为空才能进入else
		//右子数访问过的触发条件是返回时，末端所有的右子树全部遍历过了
		//依靠上一个Prepf储存的右子树进行判断，返回输出所有结点。
		//达到左，右，结点的遍历结果
		if (pf->rchild == NULL || pf->rchild == Prepf)
		{
			BT_visit(pf->data);
			//修改最近访问过的结点
			Prepf = pf;
		}
		else
		{
			//结点再次进入栈顶
			temp.Push(pf);
			//
			pf = pf->rchild;
			while (pf != NULL)
			{
				temp.Push(pf);
				pf = pf->lchild;
			}
		}

	}
	pf = Prepf = NULL;
	delete pf;
	delete Prepf;
}

层次遍历

层次遍历是从根到叶的每一层从左向右遍历的方法。
例如：

    1
   2   3 
  4 5 6 7 
8
按照层次遍历就是1 2 3 4 5 6 7 8

因此遍历从1，2，3…直到最深层，故而要求出二叉树的深度。

二叉树的深度函数

1.该方法设立了两个变量，利用类似后序遍历的方法，以最深层深度为1，（扩展NULL级叶子深度为0），逐级的同级比较叠加，同级比较中深度更深的会成为该级直到末端的结点最大深度。以此不断返回最大深度，最终得到到达根结点时的最大深度。

int Depth(BTree T)
{
	//初始化两者为0
	//每一层递归的LD，RD其实是同名不同作用域变量，并不相关。
	int LD=0, RD=0;
	//如果根结点为
	if (T == NULL)
		return 0;
	else
	{
		//根据每一个结点的左右子结点进行递归比较
		LD = Depth(T->lchild);
		RD = Depth(T->rchild);
		//从末端开始递归，类似于后序遍历
		//(附带上了同级左右结点深度的比较)
		if (LD > RD)
			return (LD + 1);
		else
			return (RD + 1);
	}
}

简便讲解：

/*
     1
   2   3 
  4 5 6 7 
8
右NULL回到8时，m=0,n=0;n++;
m=n++=1;
8回到4时，m=1,n未赋值。
RNULL回到4时，m=1,n=0; m++;
m=m++=2;
4回到2时，m=2,n未赋值。
5回到2时，m=2,5向下直到末尾，n=n++=1;m++;
2回到1时，m=3,n未赋值。
3回到1时，m=3,3向下直到末尾，n=n++(n++)=2;m++;
递归结束。
深度返回为4。
*/

2.该方法是上述方法的简便表现形式，不再使用遍历储存值，而是直接用同级函数递归比较。同级指同一结点层级。

int Depth_E(BTree T)
{
	if (T == NULL)
		return 0;
	else
		return Depth_E(T->lchild) > Depth_E(T->rchild) ? (Depth_E(T->lchild) + 1) : (Depth_E(T->rchild) + 1);
}

层次遍历

函数原型：

//层次遍历
void LevelOrderTraverse(const BTree T);
void Level_show(const BTree, int leveldep);

函数实现：

//层级遍历函数,根据层级遍历输出目标层级的所有值
void Level_show(const BTree T, int leveldep)
{
	using std::cout;
	//保障正确性,如果该结点指向为NULL，则结束程序（不输出）
	if (!T)
	{
		std::cout << "#";
		return;
	}
	if (leveldep == 1)//当层级为1时，达到目标层数，并且这个叶子结点存在
		BT_visit(T->data);
	else
	{
	//最终遍历到目标高度并按照左右左右方式输出
		Level_show(T->lchild, leveldep - 1);
		Level_show(T->rchild, leveldep - 1);
	}
}

void LevelOrderTraverse(const BTree T)
{
	//得到树的最大深度
	int Dep_T = Depth_E(T);
	//最大深度时也要遍历到 从1层（根结点）到达最大深度
	for (int i = 1; i <=Dep_T; i++)
		Level_show(T, i);
}

遍历结果示例

例子

使用的二叉树示例：
                     1
           2                    3
     4          5          6         7
  8    9    0     1     2     3   4      5

结果

在这里插入图片描述

代码仅供参考，如有错误，敬请指出

- - - - 分割线：关于非递归使用到的类方法的修正 - - - -

博主混淆了栈和队列的使用方法，导致内存越界，经过修改后，程序不再出现月结与泄露问题，下面是代码，仅供参考，当作博主学习路上的记录。

Sqstack::Sqstack()
{
	// new 和delete ;malloc，ralloc和free要配套使用。
	//_stack.Base = new BTree[MAXSIZE];
	_stack.Base = (BTree*)malloc(MAXSIZE * sizeof(BTree));
	_stack.stacksize = MAXSIZE;
	_stack.Top = _stack.Base;
	//储存元素个数为0
	_stack.stacknum = 0;
}

Sqstack::~Sqstack() 
{
	free(_stack.Base);
	_stack.Top=_stack.Base = NULL;
	_stack.stacksize = _stack.stacknum = 0;
};

void Sqstack::Push(const BTree T)
{
	if (_stack.stacknum >= MAXSIZE)
	{
		_stack.Base = (BTree*)realloc(_stack.Base, (_stack.stacksize + MAXSIZE) * sizeof(BTree));
		if (!_stack.Base)
			exit(OVERFLOW);
		_stack.Top = _stack.Base + _stack.stacksize;
		_stack.stacksize += MAXSIZE;
	}
	*_stack.Top++ = T;
	_stack.stacknum++;
}

bool Sqstack::Is_empty()
{
	 return _stack.stacknum == 0;
}

BTree Sqstack::Pop()
{
	if (Is_empty())
		return ERROR;
	_stack.stacknum--;
	return *(--_stack.Top);
}

BTree Sqstack::GetTop()
{
	//如果栈为空栈,则返回值为ERROR
	if (Is_empty())
	{
		return ERROR;
	}
	return *(_stack.Top - 1);
}
鱼非愚而为瑜
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树性质 遍历方式
dycy的博客
09-29 178
二叉树性质 遍历方式二叉树一、性质二、遍历1.前序遍历2.中序遍历3.后序遍历4.层序遍历 二叉树 由一个由有限节点所组成的集合，此集合可以为空集合，或由一个树根及左右两个子树所组成。简单地说，二叉树最多只能有两个子节点，就是度小于或等于2。 形态： 特殊二叉树： 1.满二叉树 如果二叉树的高度为h(h>=0),树的节点为2^h-1，则称之为满二叉树（即除叶节点外的所有节点都有两个子节点）。 2.完全二叉树 假设二叉树的深度h 节点数小于2^h-1 节点的编号方式如同深度为h的满二叉树 从左到右，
二叉树的建立、三种（递归、非递归）遍历方法
尽人事，听天命
06-08 1992
二叉树定义： 1.有且仅有一个特定的称之为根root的结点 2.当n>1时，除根结点之外的其余结点分为两个互不相交的子集。他们称为二叉树的左子树和右子树。 二叉树的一种建立方法： 若对有n个结点的完全二叉树进行顺序编号（1=1）的结点。 当i=1时，该结点为根，它无双亲结点; 当i>1时，该节点的双亲编号为[i/2]; 若2i 当2i+1 利用上个性质，对任意二叉树，先按满二叉树
二叉树的性质及遍历
Jefferson__的博客
07-19 366
二叉树的性质 1.性质一：在二叉树的第i层上至多有2^(i-1)个结点（i >= 1) 2.性质二：深度为k的二叉树至多有2^k-1个结点（k >= 1) 3.性质三：对任何一颗二叉树T，如果其终端结点数为n0, 度为2的结点数为n2,则n0 = n2+1. 4.性质四：具有n个结点的完全二叉树的深度为 log2n(向下取整)+1. ...
二叉树的性质和遍历
m0_51711089的博客
07-10 285
二叉树的形式： 二叉树结点的构建： 二叉树的寻找与修改： 二叉树的插入： 二叉树的建立： //二叉树的遍历： 二叉树的遍历有4种方法，分别是先序，中序，后序遍历和层次遍历，其中的"先中后都是指根节点遍历所在的位置"，且左子树的遍历永远在右子树前面； 前三者用的是DFS,后者则是用BFS 根据二叉树的递归定义：可以将树的遍历分解为对根节点，左子树，右子树这三部分的遍历； //可以通过访问的结点的顺序从而确定一棵树，先序（第一个为根结点）和后序（最后一个为根节
二叉树的基本性质与遍历
Pxx520Tangtian的博客
06-22 432
二叉树：就是一棵树中每个结点最多只有两个结点，可以没有结点，也可以只有一个结点，也可以为空结点下面说一下二叉树的常见形态： 满二叉树与完全二叉树的区别： 满二叉树就是除了叶子结点之外，每一个结点都有两个孩子 完全二叉树就是每一个结点不一定有两个孩子，但是如果出现在同一层，完全二叉树结点的i位置与满二叉树结点的 i位置编号相同，就是完全二叉树。 所以，满二叉树一定是完全二叉树，但是完全二叉树不一定是满二叉树然后来说一下二叉树的性质： 1.在
二叉树的四种遍历（非递归）
冷咖啡离开了杯垫，来到了博客
03-14 154
class treeNode: def __init__(self, val, left=None, right=None): self.val = val self.left = left self.right = right def first_order(root): if not root: ...
二叉树的四种遍历方式（递归和非递归）
qq_43100957的博客
03-11 392
这篇文章的目的只是整理几个常用的二叉树递归/非递归遍历的模板函数，方便用到的时候凭借记忆写出来即可。内容没多少技术含量，写给自己看的，权当参考。 前序遍历 递归：很简单，按照根左右的逻辑访问就是。 public List<Integer> preorderTraversal(TreeNode root){ List<Integer> res = new Ar...
二叉树的创建与三种遍历的递归与非递归实现
06-09
二叉树的创建与三种遍历的递归与非递归实现 包括二叉树的动态创建，前序遍历，中序遍历，后续遍历的递归与非递归方法的实现。
二叉树递归与非递归遍历
11-03
二叉树遍历主要有三种基本方法：前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）和后序遍历（Postorder Traversal）。这三种遍历方式都分为递归和非递归两种实现方式。 **递归遍历** 1. **前序...
遍历二叉树的4个非递归算法.rar_binary tree_二叉树_二叉树 非递归 遍历_递归_遍历 CSharp
09-14
二叉树遍历是理解和操作二叉树的关键技能，通常包括三种主要的递归方法：前序遍历、中序遍历和后序遍历，以及一种非递归方法——层次遍历。本资源"遍历二叉树的4个非递归算法.rar"提供了C#语言实现的这四种非递归...
java实现二叉树的创建及5种遍历方法(总结)
08-30
本文将详细介绍如何使用Java创建二叉树以及实现五种不同的遍历方法：递归先序、中序、后序遍历，非递归的前序和中序遍历。以下是对这些知识点的详细说明： 1. **二叉树的创建**： 创建二叉树通常有两种方式：通过...
基于Java实现的二叉树的创建以及三种遍历.zip
11-14
本资料包主要探讨了如何在Java中创建二叉树以及其三种基本遍历方法：前序遍历、中序遍历和后序遍历。首先，我们需要理解二叉树节点的定义，它通常包含一个数据字段和两个指向子节点的引用。 1. **二叉树节点定义**...
C++二叉树的创建、递归及非递归遍历（前、中、后、层序）
MilkLeong的博客
02-14 1119
定义二叉树结点类型： typedef struct BinNode { ElementType data; BinNode *Left; BinNode *Right; }BinTree; 主函数： int main() { BinTree *CreatePre(BinTree* &BT); void InorderTraversal(BinTre...
二叉树 ——（创建与非递归遍历）
Scl_Diligent的博客
07-20 656
二叉树 定义： 二叉树是结点的有限集合，这个集合或者是空的，或者由一个根结点或两棵互不相交的称为左子树的和右子树的二叉树组成。 特点： 1）每个结点至多有二棵子树(即不存在度大于2的结点) 2）二叉树的子树有左、右之分，且其次序不能任意颠倒 两种特殊的二叉树： （1）满二叉树：一棵深度为k且有2k-1个结点的二叉树。 （对树中结点按从上到下、从左到右的顺序进行编号） （...
二叉树的创建以及三种方式的遍历（递归与非递归）
霉透了的橙子
07-03 1567
先序遍历的顺序创建二叉树 输入一段字符串其中以’#'代表NULL，其余字符表示结点的值，按照先序遍历的顺序创建二叉树 例如字符串 "ABC##DE#G##F###" 表示该二叉树为 其中 # 代表空 代码实现 private Node createBiTree(Node node) { //先序遍历顺序建立二叉树 if(chars[index] == '#') { //如果当前输入的字符为‘#’标识没有结点值为null node = null; } els
二叉树三种遍历方式的六种实现方法 和 层次遍历
aift的专栏
09-10 1195
基本概念不再赘述，下面直接给出代码： #include <iostream> #include <string> #include <stack> #include <vector> using namespace std; struct Node { int val; Node * left; Node * right; Node(int ...
二叉树的创建、递归遍历与非递归遍历（C语言）
Septem_ccn的博客
01-24 583
二叉树的创建要注意使用结构体指针的指针，这样才能保证使用时可以对内存中的对应位置进行修改。创建时使用到了递归。其中先序遍历与后序遍历之间存在关系（注意观察代码），后序遍历的相反顺序是将先序遍历调整入栈顺序得到的。这里使用的是孩子兄弟关系的二叉树，其中FirstChild为左孩子，NextSibling为右孩子。递归遍历的核心是访问数据时的顺序，其决定了遍历类型。非递归遍历主要使用了栈作为递归的替代，较为复杂一点。1.头文件与二叉树的节点。5.二叉树的非递归遍历。4.二叉树的递归遍历。
二叉树的四种遍历（递归、非递归）
lqf的专栏
09-30 3631
1、递归遍历/** * 先序遍历 * @param root */ public void printFirstTree(TreeNode root){ if(root!=null){ System.out.print(root.val); printFirstTree(root.le
算法练习题13——除自身以外数组的乘积（动态规划）
最新发布
hello77的blogggg 祝你得偿所愿
09-04 450
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值