【数据结构】二叉树的实现&递归遍历（完整代码）

置顶 已于 2022-05-19 20:22:08 修改
阅读量1.9w 收藏 148
点赞数 22
分类专栏： 数据结构的模拟实现 文章标签： 二叉树的递归遍历 二叉树的非递归遍历 二叉树的节点个数 二叉树的层序遍历
于 2019-02-23 14:03:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly_6699/article/details/87891642
版权

本次模拟二叉树实现的功能

1.按要求创建一棵树
2.计算树节点，树叶子节点的个数
3.输出树中第n层的节点个数
4.关于树前序，中序，后序的递归遍历
5.树的层序遍历
6.判断树是否为完全二叉树
7.树的前序，中序，后序的非递归遍历

其中二叉树非递归遍历具体实现的讲解,可参考下篇博客： 二叉树的非递归遍历

注意：
二叉树的递归遍历实现：直接按遍历顺序递归调用
二叉树的层序遍历实现：可以借用队列结构来实现
二叉树的非递归遍历实现：可以借用栈结构来实现

前序遍历: 根 – 左 – 右
中序遍历: 左 – 根 – 右
后序遍历: 左 – 右 – 根

代码示例如下：

小编提示：作者用的编译器是VS，若编译器不同，可以将代码中的#define _CRT_SECURE_NO_WARNINGS 1和 system("pause"); 注释掉，不然直接运行代码的话可能会报错哦~

Tree.h – 头文件
// #define _CRT_SECURE_NO_WARNINGS 1
#ifndef __TREE_H__   //宏的使用，主要防止头文件的重复包含和编译
#define __TREE_H__ 

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

typedef char BTDataType;
typedef struct BinaryTreeNode  //树节点定义
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

//创建树
BTNode *BinaryTreeCreate(BTDataType*a, int*pi);
//销毁树
void BinaryTreeDestory(BTNode* root);
//树的结点
int BinaryTreeSize(BTNode* root);
//树的叶子结点
int BinaryTreeLeafSize(BTNode* root);
//树某一层的结点
int BinaryTreeLevelkSize(BTNode* root, int k);
//找到某个元素
BTNode *BinaryTreeFind(BTNode* root, BTDataType x);
//遍历
void BinaryTreePrevOrder(BTNode* root);  //前序
void BinaryTreeInOrder(BTNode* root);  //中序
void BinaryTreePostOrder(BTNode* root);  //后序
//层序遍历
void BinaryTreeLevelOrder(BTNode* root);
//判断是否完全二叉树
int BinaryTreeComplete(BTNode* root);
//非递归遍历
void BinaryPrevOrder(BTNode* root);  //前序
void BinaryInOrder(BTNode* root);  //中序
void BinaryPostOrder(BTNode* root);  //后序
//测试类
void Test();


 //队列定义以及操作声明
typedef BTNode* QDataType;
typedef struct QueueNode  
{
	QDataType _data;
	struct QueueNode* _next;
}QNode;   //定义队列节点结构

typedef struct Queue
{
	QNode* _head;
	QNode* _tail;
}Qu;   //定义队列指针结构

void QueueInit(Qu* pq);
void QueueDestory(Qu* pq);
void QueuePrint(Qu* pq);
QNode* BuyQueueNode(QDataType x);
void QueuePush(Qu* pq, QDataType x);
void QueuePop(Qu* pq);
QDataType QueueFront(Qu* pq);
QDataType QueueBack(Qu* pq);
int QueueEmpty(Qu* pq);
int QueueSize(Qu* pq);
void TestQueue();

 //栈定义以及操作声明
typedef BTNode* STDataType;
typedef struct Stack 
{
	STDataType* _a;
	int _top;
	int _capacity;
}Stack;  //定义栈结构

void StackInit(Stack* ps);
void StackDestory(Stack* ps);
void StackPush(Stack *ps, STDataType x);
void StackPop(Stack* ps);
STDataType  StackTop(Stack* ps);
int StackEmpty(Stack* ps);
int StackSize(Stack* ps);
void StackPrint(Stack* ps);
void TestStack();

#endif //__TREE_H__
Tree.c – 树的操作
// #define _CRT_SECURE_NO_WARNINGS 1
#include "Tree.h"

BTNode *BinaryTreeCreate(BTDataType*a, int* pi)  //创建树
{
		if (a[*pi] == '#')
		{
			(*pi)++;
			return NULL;
		}
			BTNode* root = (BTNode*)malloc(sizeof(BTNode));
			root->_left = root->_right = NULL;
			root->_data = a[*pi];
			(*pi)++;
			root->_left = BinaryTreeCreate(a, pi);
			root->_right = BinaryTreeCreate(a, pi);
			return root;		
}

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

int BinaryTreeSize(BTNode* root)  //统计树节点个数
{
	if (root == NULL) 
		return 0;
	return 1 + BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right);
}

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);
	}
}

int BinaryTreeLevelkSize(BTNode* root, int k)  //递归--统计树中第k层的节点个数
{
	if (root == NULL)		return 0;
	if (k==1)
		return 1;
	return BinaryTreeLevelkSize(root->_left,k-1) + BinaryTreeLevelkSize(root->_right,k-1);
}

BTNode *BinaryTreeFind(BTNode* root, BTDataType x)  //找到某个树节点
{
	BTNode* ret;
	if (root == NULL)	
		return NULL;
	if (root->_data == x)   
		return root;
	 ret = BinaryTreeFind(root->_left, x);
	{
		if (ret)
			return ret;
		ret = BinaryTreeFind(root->_right, x);
		if (ret)
			return ret;
	}	
	return NULL;
}

void BinaryTreePrevOrder(BTNode* root)   //递归--前序遍历
{
	if (root == NULL)
		return;
	printf("%c ", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}

void BinaryTreeInOrder(BTNode* root)   //递归--中序遍历
{
	if (root == NULL)
		return;
	BinaryTreeInOrder(root->_left);
	printf("%c ", root->_data);
	BinaryTreeInOrder(root->_right);
}

void BinaryTreePostOrder(BTNode* root)   //递归--后序遍历
{
	if (root == NULL)
		return;
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}

void BinaryTreeLevelOrder(BTNode* root)  //层序遍历
{
	Qu q;
	QueueInit(&q);
	if (root != NULL)
	{
		QueuePush(&q, root);
		while (QueueEmpty(&q) != 0)
		{
			BTNode* front = QueueFront(&q);
			printf("%c ", front->_data);
			QueuePop(&q);

			if (front->_left)
			    QueuePush(&q, front->_left);
			if (front->_right)
			    QueuePush(&q, front->_right);
		}
	}
}

int BinaryTreeComplete(BTNode* root)   //判断树是否是完全二叉树
{
	Qu q;
	QueueInit(&q);
	if (root != NULL)
	{
		QueuePush(&q, root);
		while (QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			QueuePop(&q);
			if (front == NULL)
				break;
			QueuePush(&q, front->_left);
			QueuePush(&q, front->_right);
		}
		while (QueueEmpty(&q) )
		{
			BTNode* front = QueueFront(&q);
			if (front != NULL)
			{
				QueueDestory(&q);
				return 0;
			}	
			QueuePop(&q);
		}
		return 1;
	}	
	return 0;
}

void BinaryPrevOrder(BTNode* root)   //非递归--前序遍历
{
	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	while (StackEmpty(&st) != 0 || cur != NULL)
	{
		while (cur != NULL)
		{
			printf("%c ", cur->_data);
			StackPush(&st, cur);
			cur = cur->_left;
		}
		BTNode* top = StackTop(&st);
		StackPop(&st);
		cur=top->_right;
	}
}

void BinaryInOrder(BTNode* root)    //非递归--中序遍历
{
	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	while (StackEmpty(&st) != 0 || cur != NULL)
	{
		while (cur != NULL)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		BTNode* top = StackTop(&st);
		printf("%c ", top->_data);
		StackPop(&st);
		cur = top->_right;
	}
}

void BinaryPostOrder(BTNode* root)    //非递归--后序遍历
{
	BTNode* cur = root;
	BTNode* prev = NULL;
	Stack st;
	StackInit(&st);
	while (cur || StackEmpty(&st) != 0)
	{
		while (cur != NULL)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		BTNode* top = StackTop(&st); 
		if (top->_right == NULL || top->_right == prev)
		{
			StackPop(&st);
			printf("%c ", top->_data);
			prev = top;
		}
		else cur=top->_right;
	} 
}

void Test()  
{
   char a[20] = "ABD##E#H##CF##G##";
   //int sz = (sizeof(a) / sizeof(a[0]));
   int pi = 0;
   int i = 0;
   BTNode* root = BinaryTreeCreate(a, &pi);
   printf("树创建成功！\n");
   printf("树点的个数是： ");
   printf("%d\n", BinaryTreeSize(root));
   printf("树叶子结点的个数是： ");
   printf("%d\n", BinaryTreeLeafSize(root));
   printf("第3层结点的个数是： ");
   printf("%d\n", BinaryTreeLevelkSize(root, 3));
   printf("树前序遍历的结果是： ");
   BinaryTreePrevOrder(root);
   printf("\n");
   printf("树中序遍历的结果是： ");
   BinaryTreeInOrder(root);
   printf("\n");
   printf("树后序遍历的结果是： ");
   BinaryTreePostOrder(root);
   printf("\n");
   printf("树层序遍历的结果是： ");
   BinaryTreeLevelOrder(root);
   printf("\n");
   i=BinaryTreeComplete(root);
   if (i == 1) printf("此树是完全二叉树。\n ");
   else  printf("此树非完全二叉树。\n ");
   printf("\n\n\n 下面是树的非递归遍历！\n");
   printf("树前序遍历的结果是： ");
   BinaryPrevOrder(root);
   printf("\n");
   printf("树中序遍历的结果是： ");
   BinaryInOrder(root);
   printf("\n");
   printf("树后序遍历的结果是： ");
   BinaryPostOrder(root);
   printf("\n");
  BinaryTreeDestory(root);
  printf("销毁成功！\n");
}
Queue.c – 队列的操作(辅助层序遍历)
// #define _CRT_SECURE_NO_WARNINGS 1
#include "Tree.h"

void QueueInit(Qu* pq)  //队列初始化
{
	QDataType x = 0; 
	assert(pq);
	pq->_head = BuyQueueNode(x); 
	pq->_tail = pq->_head;   
}

void QueueDestory(Qu* pq)  //队列销毁
{
	QNode* cur = pq->_head->_next; //节点指针指向队列头节点
	while (cur != NULL)
	{
		QNode* next = cur->_next; //记录下一个节点
		free(cur);  //释放当前节点
		cur = next; //指针指向下一个节点
	}
} 

QNode* BuyQueueNode(QDataType x)  //新增队列节点
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));  //新增一个节点
	newNode->_data = x;  //为节点赋值
	newNode->_next = NULL;  //节点指针初始化
	return newNode;  //返回当前新增的节点
}

void QueuePush(Qu* pq, QDataType x)  //指定值进入队列
{	
	QNode* newnode = BuyQueueNode(x); //新增指定值的节点
	pq->_tail->_next = newnode;  //连接新节点
	pq->_tail = newnode;  //队列尾指针后移
}

void QueuePop(Qu* pq)  //出队列
{
	assert(pq);
	QNode* 	cur = pq->_head->_next; //结点指针
	if (cur == NULL)  //无节点直接返回
	{
		return;
	}
	if (cur == pq->_tail)  //只有一个节点，尾节点前移
	{
		pq->_tail = pq->_head;
	}
	pq->_head->_next = cur->_next;  //将头节点后移
	free(cur);    //节点释放
}

QDataType QueueFront(Qu* pq)  //返回队列头部的值
{
	QNode* 	cur = pq->_head->_next;
	assert(pq);
	return cur->_data;
}

QDataType QueueBack(Qu*pq)  //队列尾部的值
{
	assert(pq);
	return pq->_tail->_data;
}

int QueueEmpty(Qu* pq)  //队列判空
{
	QNode* 	cur = pq->_head->_next;
	if (cur == NULL)
		return 0;
	else return 1;
}

int QueueSize(Qu* pq)  //队列节点总数
{
	int count = 0;
	QNode* 	cur = pq->_head->_next;
	if (cur == NULL)
		return 0;
	while (cur)
	{
		count++;
		cur = cur->_next;
	}
	return count;
}

void QueuePrint(Qu* pq)  //队列打印
{
	QNode* 	cur = pq->_head->_next;
	assert(pq);
	while (cur != NULL)
	{
		printf("%d  ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}
Stack.c – 栈的操作(辅助非递归遍历)
#define _CRT_SECURE_NO_WARNINGS 1
#include "Tree.h"

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackDestory(Stack* ps)
{
	assert(ps);
	ps->_capacity = 0;
	ps->_top = 0;
	free(ps->_a);
	ps->_a = NULL;
}

void StackPush(Stack *ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		size_t newcapacity = (ps->_capacity == 0 ? 4 : ps->_capacity * 2);
		ps->_a = (STDataType*)realloc(ps->_a, sizeof(STDataType)*newcapacity);
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top]= x;
	ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps&&ps->_top>0);
	ps->_top--;
}

STDataType  StackTop(Stack* ps)
{
	assert(ps&&ps->_top>0);
	return ps->_a[ps->_top - 1];
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
		return 0;
	else return 1;
}

int StackSize(Stack* ps)
{
	assert(ps);
	STDataType size = ps->_top;
	return size;
}

void StackPrint(Stack* ps)
{
	assert(ps);
	while (StackEmpty(ps) != 0)
	{
		printf("%d ", StackTop(ps));
		StackPop(ps);
	}
	printf("\n");
}
test.c – 主文件
#define _CRT_SECURE_NO_WARNINGS 1
#include "Tree.h"


int main()
{
	printf("      *******二叉树的实现******\n");
	Test();
	printf("\n");
	printf("\n");
	printf("\n");
	
//	system("pause");
	return 0;
}
运行结果如下:

在这里插入图片描述

ly_1115
关注
  • 22
    点赞
  • 踩
  • 148
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
C语言经典算法之二叉树的中序遍历(递归实现)
weixin_56154577的博客
01-30 1855
二叉树的中序遍历（Inorder Traversal）是深度优先遍历策略的一种，对于一个二叉搜索树（BST），中序遍历可以得到一个递增的有序序列。
二叉树递归代码及图解（c语言）：（前序，中序，后续，节点与叶子个数）
weixin_61125362的博客
12-08 1251
二叉树遍历代码，递归详细图解（c语言）：我们用链式结构创建一棵二叉树，对树的前序，中序，后序，树节点个数，叶子个数，树的高度进行递归分析，有详细的图解。
二叉树的实现(递归实现)
最新发布
2402_82658387的博客
05-27 766
二叉树中重要接口的实现
【数据结构】-----二叉树（递归、层次实现二叉树的遍历）
m0_55752775的博客
10-19 2394
递归实现二叉树前序遍历 递归实现二叉树中序遍历 递归实现二叉树后序遍历 二叉树的销毁 二叉树层序遍历（用队列实现） 二叉树节点个数 二叉树叶子节点个数 二叉树第k层节点个数 二叉树查找值为x的节点 二叉树深度/高度
用java实现二叉树的后序遍历（递归和迭代）
m0_57248752的博客
03-29 1823
用java实现二叉树的后序遍历（递归和迭代两种方法），有详细注释以及图解
二叉树的层次构造&层次遍历（递归实现、队列实现）
wawalker的博客
08-03 1184
typedef struct node{ int data; node *left; node *right; }Node,*Tree; 构造 Node *generateTree(int a[],int i,int len){ Node *node = (Node *)malloc(sizeof(Node)); node->data = a[i]; node->left = nullptr; node->right = .
二叉树层次遍历代码完整代码（C语言）
xiuhhhua的博客
08-06 7930
二叉树层次遍历思路就是使用队列进行存储，当出队一个元素，则将其左右子树入队。
C语言数据结构之二叉树的非递归后序遍历算法
08-29
主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
深入理解二叉树的非递归遍历
09-05
二叉树是非线性数据结构的一种，它由节点（或称为结点）构成，每个节点包含一个值以及可能指向两个子节点的指针，通常分为左孩子和右孩子。二叉树的遍历是访问树中所有节点的过程，常见的遍历方式有三种：前序遍历、...
C语言二叉树的非递归遍历实例分析
09-04
以上代码展示了C语言中非递归遍历二叉树的实现，对于先序、中序和后序遍历分别提供了详细的函数实现。这些方法在处理大型二叉树时特别有用，因为递归可能导致调用栈溢出。通过非递归方式，我们可以有效地控制内存...
数据结构实验——二叉树的建立和遍历.zip
12-13
5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1的；度为2的；总结点数。 6.用递归公式计算二叉树的高度（BiTreeDepth(BT)=0; 当二叉树空时（BT==NULL）。 BiTreeDepth(BT)=max{ ...
数据结构实验五（二叉树的建立及遍历）题目和源程序
04-02
实验内容 1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。 2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
二叉树遍历算法的应用C语言代码
04-11
0. 建立二叉树(方法0) 1. 建立二叉树(方法1) 2. 统计叶子结点个数 3. 求二叉树的树深
二叉树的三种遍历方式（递归+非递归）完整代码
CodePanda@GPF的博客
04-02 815
package sparsearray; import java.util.Stack; public class Test { public static void main(String[] args) { // 创建节点 Node root = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node node4 = new Node(4); Node node5 = new Node(.
二叉树遍历——递归链式（C语言实现）
qq_63580639的博客
10-27 2444
递归实现二叉树的前，中，后，层，序遍历
树--先序遍历构建二叉树
RXY24601的博客
10-18 3437
需要在先序序列中用特殊字符补充空节点，使二叉树的建立唯一。从键盘输入二叉树的节点信息，建立二叉树的存储结构。当只有一个先序序列的时候无法确定为一个一颗二叉树。在建立二叉树的过程中按照二叉树先序方式建立。按照先序遍历序列建立二叉树的二叉链表。
【数据结构与算法】递归树
dadongwudi的博客
08-21 9096
1.树、二叉树 2.二叉查找树 3.平衡二叉树、红黑树 4.递归树 一、什么是递归树 如果我们把这个一层一层的分解过程画成图，它其实就是一棵树。我们给这棵树起一个名字，叫作递归树。 时间复杂度分析的递归树法 分析每一步核心操作的时间复杂度 分析树高：最大树高和最小树高 计算每层复杂度，全加起来（放缩法调整） 二、实战 实战1:快速排序 快速排序在最好情况下，每次分区都能一分为二，这个时候用递推公式 T(n)=2T(2n​)+n，很容易就能推导出时间复杂度是 O(nlogn)。 分割算法是O(n) 2
【leetcode】递归-二叉树中序遍历
码农研究僧的博客
05-05 307
题目： 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 示例 1： 输入：root = [1,null,2,3] 输出：[1,3,2] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 示例 4： 输入：root = [1,2] 输出：[2,1] 示例 5： 输入：root = [1,null,2] 输出：[1,2] 提示： 树中节点数目在范围 [0, 100] 内 -100 <= Node.val <= 100 进阶: 递
【二叉树2】递归遍历【附代码及分析】
m0_57733045的博客
01-21 361
写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。解读一下代码，首先是定义部分，在上一篇文章中解释了java中对left和right的理解，剩下部分就是构造函数的书写，记得复习，可能会有提问。剩下的就是在数组中添加下一个节点数据的过程，首先是根节点/中节点，然后是左节点，但是这里对左节点又做了一次传入前序遍历的过程，传入两个参数，根节点/中节点和存放结果的数组。
c语言数据结构二叉树的非递归遍历代码
05-21
二叉树的非递归遍历通常使用栈来实现。以下是三种非递归遍历方式的代码实现： 1. 非递归中序遍历： ``` void inorderTraversal(TreeNode* root) { stack<TreeNode*> st; TreeNode* cur = root; while (cur != nullptr || !st.empty()) { if (cur != nullptr) { st.push(cur); cur = cur->left; } else { cur = st.top(); st.pop(); cout << cur->val << " "; cur = cur->right; } } } ``` 2. 非递归先序遍历： ``` void preorderTraversal(TreeNode* root) { stack<TreeNode*> st; if (root != nullptr) { st.push(root); } while (!st.empty()) { TreeNode* cur = st.top(); st.pop(); cout << cur->val << " "; if (cur->right != nullptr) { st.push(cur->right); } if (cur->left != nullptr) { st.push(cur->left); } } } ``` 3. 非递归后序遍历： ``` void postorderTraversal(TreeNode* root) { stack<TreeNode*> st; TreeNode* prev = nullptr; if (root != nullptr) { st.push(root); } while (!st.empty()) { TreeNode* cur = st.top(); if ((cur->left == nullptr && cur->right == nullptr) || (prev != nullptr && (prev == cur->left || prev == cur->right))) { cout << cur->val << " "; st.pop(); prev = cur; } else { if (cur->right != nullptr) { st.push(cur->right); } if (cur->left != nullptr) { st.push(cur->left); } } } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值