二叉树(递归实现先序遍历,中序遍历,后序遍历,非递归实现先序遍历,中序遍历,后序遍历,二叉树层序遍历,二叉树结点个数,二叉树叶子结点个数,判断一颗树是否为完全二叉树)

最新推荐文章于 2021-03-01 14:56:22 发布
最新推荐文章于 2021-03-01 14:56:22 发布
阅读量714 收藏 7
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gp1330782530/article/details/100016779
版权

二叉树(递归实现先序遍历,中序遍历,后序遍历,非递归实现先序遍历,中序遍历,后序遍历,二叉树层序遍历,二叉树结点个数,二叉树叶子结点个数,判断一颗树是否为完全二叉树)
1.构造二叉树:通过前序遍历的数组eg:"ABD##E#H##CF##G##"构建二叉树;
2.递归实现二叉树的前中后序遍历;
3.非递归实现二叉树的前中后序遍历;
4.后序遍历销毁二叉树;
5.层序遍历:借助队列实现;
6.判断一颗二叉树是否为完全二叉树:有右没左,或有孩子且标记为1;
7.二叉树结点个数的计数通过遍历实现;
8.叶子结点的个数通过判断该结点的类型实现.
BinaryTree.h

#ifndef _BINARYTREE_H_
#define _BINARYTREE_H_

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* src);
// 递归遍历
void BinaryTreePrevOrder(BTNode* root);//先序遍历
void BinaryTreeInOrder(BTNode* root);//中序遍历
void BinaryTreePostOrder(BTNode* root);//后序遍历
void BinaryTreeLevelOrder(BTNode* root);// 层序遍历
void BinaryTreeDestory(BTNode** root);//销毁二叉树
// 非递归遍历
void BinaryTreePrevOrderNonR(BTNode* root);//先序遍历
void BinaryTreeInOrderNonR(BTNode* root);//中序遍历
void BinaryTreePostOrderNonR(BTNode* root);//后序遍历
//递归实现
int BinaryTreeLeafSize(BTNode* root);二叉树叶子结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);第K层结点个数
//非递归实现
int BinaryTreeSizeNonR(BTNode* root);二叉树结点个数
int BinaryTreeLeafSizeNonR(BTNode* root);//二叉树叶子结点个数
int BinaryTreeLevelKSizeNonR(BTNode* root, int k);//第K层结点个数
int BinaryTreeComplete(BTNode* root);// 判断二叉树是否是完全二叉树
#endif // !_BINARYTREE_H_

Queue.h

#ifndef _QUEUE_H_
#define _QUEUE_H_
#include "BinaryTree.h"

typedef BTNode * QueueDataType;

typedef struct QueueNode
{
	QueueDataType _data;
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue {
	QueueNode * _head;
	QueueNode * _real;
}Queue;

void QueueInit(Queue* plist);
void QueueDestory(Queue* plist);
void QueuePop(Queue* plist);
void QueuePush(Queue* plist, QueueDataType x);
QueueDataType QueueTop(Queue* plist);
int QueueEmpty(Queue* plist);
int QueueSize(Queue* plist);

#endif //_QUEUE_H_

Stack.h

#ifndef _Stack_H_
#define _Stack_H_


#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "BinaryTree.h"

typedef BTNode* StDataType;

typedef struct Stack
{
	StDataType* array; // 指向动态开辟的数组
	size_t size; // 有效数据个数
	size_t capicity; // 容量空间的大小
}Stack;

void StackInit(Stack* psl, size_t capacity);
void StackDestory(Stack* psl);
void CheckCapacity(Stack* psl);
void StackPush(Stack* psl, StDataType x);
void StackPop(Stack* psl);
StDataType StackTop(Stack* psl);
int StackEmpty(Stack* psl);

#endif // _Stack_H_

Binarytree.c

#include "BinaryTree.h"
#include "Queue.h"
#include "Stack.h"

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* src) {
	static int s_n = 0;
	if (src[s_n] == '#') {
		s_n++;
		return NULL;
	}
	BTNode* cur = (BTNode*)malloc(sizeof(BTNode));
	cur->_data = src[s_n];
	s_n++;
	cur->_left = BinaryTreeCreate(src);
	cur->_right = BinaryTreeCreate(src);
	return cur;
}

//递归遍历
//前序遍历(递归)
void BinaryTreePrevOrder(BTNode* root) {
	//assert(root);
	if (root) {
		putchar(root->_data);
		BinaryTreePrevOrder(root->_left);
		BinaryTreePrevOrder(root->_right);
	}
}

//中序遍历(递归)
void BinaryTreeInOrder(BTNode* root) {
	//assert(root);
	if (root) {
		BinaryTreeInOrder(root->_left);
		putchar(root->_data);
		BinaryTreeInOrder(root->_right);
	}
}

//后序遍历(递归)
void BinaryTreePostOrder(BTNode* root) {
	//assert(root);
	if (root) {
		BinaryTreePostOrder(root->_left);
		BinaryTreePostOrder(root->_right);
		putchar(root->_data);
	}
}

//层序遍历(队列实现)
void BinaryTreeLevelOrder(BTNode* root) {
	BTNode* cur;
	Queue qu;
	QueueInit(&qu);
	QueuePush(&qu, root);
	while (!QueueEmpty(&qu)) {
		cur = QueueTop(&qu);
		putchar(cur->_data);
		if (cur->_left) {
			QueuePush(&qu, cur->_left);
		}
		if (cur->_right) {
			QueuePush(&qu, cur->_right);
		}
		QueuePop(&qu);
	}
	QueueDestory(&qu);
}

//销毁二叉树
void BinaryTreeDestory(BTNode** root) {
	assert(root);
	if (root) {
		BinaryTreePostOrder((*root)->_left);
		BinaryTreePostOrder((*root)->_right);
		free(*root);
		*root = NULL;
	}
}

//非递归遍历(均用栈实现)
//前序遍历(非递归)
void BinaryTreePrevOrderNonR(BTNode* root) {
	assert(root);
	BTNode* cur = root;
	Stack st;
	StackInit(&st, 100);
	while (cur)	{
		putchar(cur->_data);
		if (cur->_right) {
			StackPush(&st, cur->_right);
		}
		if (cur->_left) {
			cur = cur->_left;
		}
		else {
			cur = StackTop(&st);
			StackPop(&st);
		}
	}
	StackDestory(&st);
}

//中序遍历(非递归)
void BinaryTreeInOrderNonR(BTNode* root) {
	assert(root);
	BTNode* cur = root;
	Stack st;
	StackInit(&st, 100);
	while (!StackEmpty(&st) || cur) {
		for (; cur; cur = cur->_left) {
			StackPush(&st, cur);
		}
		cur = StackTop(&st);
		putchar(cur->_data);
		StackPop(&st);
		cur = cur->_right;
	}
	StackDestory(&st);
}

//后序遍历(非递归)
void BinaryTreePostOrderNonR(BTNode* root) {
	assert(root);
	BTNode* cur = root;
	Stack st;
	char tag[100];
	StackInit(&st, 100);
	do {
		for (; cur; cur = cur->_left) {
			StackPush(&st, cur);
			tag[st.size - 1] = 0;
		}
		while (!StackEmpty(&st) && tag[st.size - 1]) {
			cur = StackTop(&st);
			putchar(cur->_data);
			StackPop(&st);
		}
		if (!StackEmpty(&st)) {
			cur = StackTop(&st);
			tag[st.size - 1] = 1;
			cur = cur->_right;
		}
	} while (!StackEmpty(&st));
	StackDestory(&st);
}

//递归实现
//二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root) {
	if (root == NULL) {
		return 0;
	}
	else if ((root->_left == NULL) && (root->_right == NULL)) {
		return 1;
	}
	else {
		return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
	}
}

//第K层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k) {
	if (root == NULL || k <= 0) {
		return 0;
	}
	else if (root&&k == 1) {
		return 1;
	}
	else {
		return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
	}
}

//非递归实现
//二叉树结点个数
int BinaryTreeSizeNonR(BTNode* root) {
	assert(root);
	int count = 0;
	BTNode* cur = root;
	Stack st;
	StackInit(&st, 100);
	while (cur)	{
		count++;
		//putchar(cur->_data);
		if (cur->_right) {
			StackPush(&st, cur->_right);
		}
		if (cur->_left) {
			cur = cur->_left;
		}
		else {
			cur = StackTop(&st);
			StackPop(&st);
		}
	}
	StackDestory(&st);
	return count;
}

//二叉树叶子结点个数
int BinaryTreeLeafSizeNonR(BTNode* root) {
	assert(root);
	int count = 0;
	BTNode* cur = root;
	Stack st;
	StackInit(&st, 100);
	while (cur)	{
		if (cur->_left == NULL && cur->_right == NULL) {
			count++;
		}
		//putchar(cur->_data);
		if (cur->_right) {
			StackPush(&st, cur->_right);
		}
		if (cur->_left) {
			cur = cur->_left;
		}
		else {
			cur = StackTop(&st);
			StackPop(&st);
		}
	}
	StackDestory(&st);
	return count;
}

//第K层结点个数
int BinaryTreeLevelKSizeNonR(BTNode* root, int k) {
	if (root == NULL || k <= 0) {
		return 0;
	}
	int cur_level_size = 0;
	int cur_level = 0;
	Queue qu;
	QueueInit(&qu);
	QueuePush(&qu,root);
	while (!QueueEmpty(&qu)) {
		cur_level++;
		cur_level_size = QueueSize(&qu);
		if (cur_level == k) {
			break;
		}
		int tmp_count = 0;
		while (tmp_count < cur_level_size) {
			tmp_count++;
			root = QueueTop(&qu);
			QueuePop(&qu);
			if (root->_left) {
				QueuePush(&qu, root->_left);
			}
			if (root->_right) {
				QueuePush(&qu, root->_right);
			}
		}
	}
	QueueDestory(&qu);
	if (cur_level == k) {
		return cur_level_size;
	}
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root) {
	int tag = 0;
	BTNode* cur;
	Queue qu;
	QueueInit(&qu);
	QueuePush(&qu, root);
	while (!QueueEmpty(&qu)) {
		cur = QueueTop(&qu);
		putchar(cur->_data);
		if (root->_right&&root->_left == NULL) {
			return 0;
		}
		if (tag && (root->_left || root->_right)) {
			return 0;
		}
		if (cur->_left) {
			QueuePush(&qu, cur->_left);
		}
		if (cur->_right) {
			QueuePush(&qu, cur->_right);
		}
		else {
			tag = 1;
		}
		QueuePop(&qu);
	}
	QueueDestory(&qu);
	return 1;
}

Queue.c

#include "Queue.h"

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void QueueInit(Queue* plist) {
	assert(plist);
	plist->_head = NULL;
	plist->_real = NULL;
}

void QueueDestory(Queue* plist)
{
	assert(plist);
	QueueNode * tmp;
	while (plist->_head) {
		tmp = plist->_head;
		plist->_head = plist->_head->_next;
		free(tmp);
	}
}

void QueuePop(Queue* plist)
{
	assert(plist);
	QueueNode * tmp;
	if (plist->_head) {
		tmp = plist->_head;
		plist->_head = plist->_head->_next;
		free(tmp);
	}
}

void QueuePush(Queue* plist, QueueDataType x) {
	assert(plist);
	QueueNode * cur = (QueueNode *)malloc(sizeof(QueueNode));
	cur->_data = x;
	cur->_next = NULL;
	if (QueueEmpty(plist)) {
		plist->_head = plist->_real = cur;
		return;
	}
	plist->_real->_next = cur;
	plist->_real = cur;
}

int QueueEmpty(Queue* plist) {
	assert(plist);
	return plist->_head == NULL;
}

QueueDataType QueueTop(Queue* plist) {
	assert(plist);
	if (QueueEmpty(plist)) {
		return (QueueDataType)0;
	}
	return plist->_head->_data;
}

//队列长度
int QueueSize(Queue* plist) {
	assert(plist);
	if (plist == NULL) {
		return 0;
	}
	int count = 0;
	QueueNode* cur;
	for (cur = plist->_head; cur; cur = cur->_next) {
		count++;
	}
	return count;
}

Stack.c

#include "Stack.h"

//初始栈
void StackInit(Stack* psl, size_t capacity) {
	assert(psl);
	psl->capicity = capacity;
	psl->array = (StDataType*)malloc(capacity*sizeof(StDataType));
	assert(psl->array);
	psl->size = 0;
}

//销毁栈
void StackDestory(Stack* psl) {
	assert(psl);
	if (psl->array) {
		free(psl->array);
		psl->capicity = 0;
		psl->size = 0;
		psl->array = NULL;
	}
}

//扩容栈
void CheckCapacity(Stack* psl) {
	assert(psl);
	if (psl->size == psl->capicity) {
		psl->capicity *= 2;
		psl->array = (StDataType*)realloc(psl->size, psl->capicity*sizeof(StDataType));
	}
}

//入栈
void StackPush(Stack* psl, StDataType x) {
	assert(psl);
	CheckCapacity(psl);
	psl->array[psl->size] = x;
	psl->size++;
}

//出栈
void StackPop(Stack* psl) {
	assert(psl || psl->size);
	psl->size--;
}

//返回栈顶元素
StDataType StackTop(Stack* psl) {
	assert(psl);
	if (StackEmpty(psl)) {
		return (StDataType)0;
	}
	return psl->array[psl->size - 1];
}

//判空
int StackEmpty(Stack* psl) {
	assert(psl);
	return psl->size == 0;
}

main.c

#include "BinaryTree.h"
#include "Queue.h"
#include "Stack.h"

int main() {
	int count;
	Queue que;
	//ABD##E#H##CF##G##
	//ABD#GI##J###CE#HK###F##
	BTNode* root = BinaryTreeCreate("ABD#GI##J###CE#HK###F##");
	BinaryTreePrevOrder(root);
	putchar('\n');
	BinaryTreeInOrder(root);
	putchar('\n');
	BinaryTreePostOrder(root);
	putchar('\n');
	BinaryTreeLevelOrder(root);
	putchar('\n');
	BinaryTreePrevOrderNonR(root);
	putchar('\n');
	BinaryTreeInOrderNonR(root);
	putchar('\n');
	BinaryTreePostOrderNonR(root);
	putchar('\n');
	//printf("%d\n", BinaryTreeSize(root));
	printf("%d\n", BinaryTreeLeafSize(root));
	printf("%d\n", BinaryTreeSizeNonR(root));
	printf("%d\n", BinaryTreeLeafSizeNonR(root));
	printf("%d\n", BinaryTreeLevelKSize(root, 1));
	printf("%d\n", BinaryTreeLevelKSize(root, 2));
	printf("%d\n", BinaryTreeLevelKSize(root, 3));
	printf("%d\n", BinaryTreeLevelKSize(root, 4));
	printf("%d\n", BinaryTreeLevelKSize(root, 5));
	printf("%d\n", BinaryTreeLevelKSizeNonR(root, 1));
	printf("%d\n", BinaryTreeLevelKSizeNonR(root, 2));
	printf("%d\n", BinaryTreeLevelKSizeNonR(root, 3));
	printf("%d\n", BinaryTreeLevelKSizeNonR(root, 4));
	printf("%d\n", BinaryTreeLevelKSizeNonR(root, 5));
	BinaryTreeComplete(root);
	putchar('\n');
	system("pause");				   
	return 0;
}
三吋时光
关注
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树求叶子节点非递归
12-13
二叉树非递归求叶子节点，以及前序、中序、后序遍历算法
【刷算法】判断二叉搜索树的后序遍历序列的递归实现和非递归实现
weixin_33711641的博客
06-27 117
题目描述 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 分析 所谓二叉搜索树，也称为二叉搜索树、有序二叉树（ordered binary tree）或排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点...
二叉树的中序遍历
gxl10281的博客
06-10 501
二叉树中序遍历的规则是：若树为空，则返回空操作，否则，从根节点开始，先中序遍历二叉树的左子树，然后遍历根节点，在中序遍历二叉树的右子树。具体代码如下：void InOrderTraverse(BiTree T) { if(T==NULL)return; InOrderTraverse(T-&gt;lchild); printf("%c",T-&gt;data); InOrd...
第九周-项目2 - 二叉树遍历的递归算法
re_surmount的博客
11-02 297
/* * Copyright (c) 2017,烟台大学计算机学院 * All right reserved. * 文件名称：main.cpp * 作者：于嵩 * 完成日期：2017年11月1日 * 版本号：v1.0 * * 问题描述：顺序串
二叉查找树中序遍历非递归解法
weixin_30278311的博客
02-20 153
　　对于树的访问先是从根节点开始进行的，递归左子树和右子树，对于左子树和右子树又可以看成是一棵子树继续递归下去，访问根节点的时候它不是直接处理根节点的而是需要等待它的左子树调用完之后那么才进行处理的，左子树也是一样，当访问到它的左子树的时候也需要等待它的左子树处理完毕才处理自己。 　　这也就是先访问，后出现的特点，与一种数据结构的特点是类似的，那就是栈，栈也是 "先进后出" 的特点，其实递归来说...
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
上述代码中的三个函数都是基于栈实现的非递归遍历，它们能够有效地处理任意大小的二叉树，而不会受到递归深度限制的影响。 在实际应用中，二叉树遍历可以用来进行多种操作，如查找、复制、排序等。比如，在编译器中...
Python实现输入二叉树的先序和中序遍历，再输出后序遍历操作示例
09-20
综上所述，通过理解并掌握这些知识点，读者可以学会如何使用Python来实现二叉树的先序、中序和后序遍历的构造与输出。同时，文中提及的其他专题资料，如《Python数据结构与算法教程》、《Python编码操作技巧总结》等...
树子系统实现二叉树的创建，先序遍历，中序遍历，后序遍历，求叶子数，求结点数，求树的深度
最新发布
07-23
在这个树子系统中，我们关注的是如何创建二叉树以及对它的各种操作，如先序遍历、中序遍历、后序遍历，以及计算叶子节点数、节点总数和树的深度。 **二叉树的创建**： 创建二叉树通常涉及到动态内存分配和节点的...
二叉树的先序遍历，中序遍历，后序遍历，层级遍历
06-16
数据结构二叉树链式结构的前序遍历，中序遍历，后序遍历用递归的方法，层级遍历采用队列结构
二叉树的相关操作（非递归前序遍历，中序遍历，判断是否有序，判断两棵二叉树是否等价）
是我的博客啊
06-29 971
二叉树的非递归前序遍历： 先访问根节点，后访问左子树，后访问右子树 访问过程需要回溯，用到栈 此处seqstack为自定义栈 typedef struct tree_node{ char data; struct tree_node* lchild; struct tree_node* rchild; }treenode; typedef treenode* bintree; typede...
递归前序遍历、递归中序遍历、递归后序遍历、层序遍历和判断一棵树是否为完全二叉树
夏野和弦的博客
03-01 194
目录递归前序遍历递归中序遍历递归后序遍历层序遍历（很重要）判断一棵树是否为完全二叉树 递归前序遍历 /* * 递归 前序遍历*/ public void preorder(Visitor<E> visitor){ preorder(root,visitor); } private void preorder(Node<E> node, Visitor<E> visitor){ if (root == nu
非递归获取二叉树中叶子结点的个数
weixin_37632716的博客
12-09 1540
左孩子结点和右孩子结点都为空的结点就是叶子结点 int numberOfLeavesInBTusingLevelOrder(BinaryTreeNode root){ BinaryTreeNode temp; LLQueue q = new LLQueue(); int count = 0; if(root == null){ return 0; } q.enQueue(root); while(!q.isEmpty()){ temp = q.deQueue()
中序遍历二叉树
power8988的博客
10-23 304
先上代码：<script> var count=0; function BinaryTree(){ var Node=function(key){ this.key=key; this.left=null; this.right=null; } var insert
二叉树的基本操作精集（创建、遍历、求深度结点以及叶子结点个数）
Zxn、Sirius荣耀之路
07-31 4068
对于二叉树的操作一般的我们使用递归的方法，因为在二叉树中每一个子树又是一颗二叉树。 这篇代码主要是演示了二叉树的以下操作 二叉树的创建 二叉树的三种遍历 求解二叉树的高度 求解指定层数的结点个数 求解二叉树的叶子结点个数 /********************************************************* - Copyright (C): 2016 - File
c/c++实现利用二叉树的先序遍历和中序遍历序列重建树
路漫漫其修远兮，吾将上下而求索
01-01 2748
先序遍历中第一个结点必然是根结点，利用该结点在中序遍历中的位置，将树分为左子树和右子树，然后递归重建左子树和右子树，代码如下#include using namespace std; struct Node { char value; Node* left; Node* right; Node() { }; Node(char c, Node* l = NULL, Node
树和二叉树(顺序和链式）的遍历操作
ljj20314的博客
11-04 245
树： n个结点的有限集合，当n等于0时为空树。 任意一棵非空树满足以下条件： ⑴ 有且仅有一个特定的称为根的结点； ⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树。 树的定义采用递归方法。 结点的度：结点所拥有子树的个数 树的度：树中各结点度的最大值 叶子结点：度为0的结点 分支节点：度不为零...
403，验证二叉搜索树
数据结构和算法
09-22 235
想了解更多数据结构以及算法题，可以关注微信公众号“数据结构和算法”，每天一题为你精彩解答。也可以扫描下面的二维码关注 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4
二叉树遍历系列--中序遍历
zhangzhetaojj的博客
06-15 4707
什么是中序遍历？优先访问当前节点的左子树，然后访问当前节点，最后访问当前节点的右子树。代码实现：主要分为三部分：1. 声明一个内部类，表示树的节点。private class TreeNode&lt;K,V&gt; implements Map.Entry&lt;K,V&gt; { private K key; private V value; public TreeNo...
非递归C语言实现二叉树遍历：先序、中序、后序
"二叉树的建立和非递归遍历是数据结构中的重要概念，本文将探讨如何在C语言中实现非递归版本的先序、中序和后序遍历。" 在计算机科学中，二叉树是一种常用的数据结构，它由节点组成，每个节点有两个子节点：左子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值