二叉树——创建和遍历（递归、非递归）

最新推荐文章于 2022-11-05 17:00:50 发布
最新推荐文章于 2022-11-05 17:00:50 发布
阅读量897 收藏 10
点赞数 1
分类专栏： 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_blackbutterfly/article/details/80535187
版权

表示形式：链式结构

递归算法： 
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2

using namespace std;

typedef int Status;
typedef char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode,*BiTree;

int Nodenum = 0;
int Count = 0;

Status CreateBiTree(BiTree &T)
{
	char ch;
	cin >> ch;
	if (ch == '#')
		T = NULL;
	else
	{
		if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return OK;

}

Status PreOrderTraverse(BiTree T)
{
	if (T)
	{
		printf("%c", T->data);
		if (PreOrderTraverse(T->lchild))
			if (PreOrderTraverse(T->rchild))
				return OK;
		return ERROR;
	}
	else
		return OK;
}

Status InOrderTraverse(BiTree T)
{
	int m = 0;
	if (T)
	{
		if (InOrderTraverse(T->lchild))
			m = 1;
		cout << T->data;
		if (m)
			if (InOrderTraverse(T->rchild))
				return OK;
		return ERROR;
	}
	else
		return OK;
}

Status PostOrderTraverse(BiTree T)
{
	if (T)
	{
		if (PostOrderTraverse(T->lchild))
			if (PostOrderTraverse(T->rchild))
			{
				cout << T->data;
				return OK;
			}
		return ERROR;

	}
	else
		return OK;
}

Status NodeCount(BiTree T)
{
	if (T)
	{
		Nodenum++;
		if (NodeCount(T->lchild))
			if (NodeCount(T->rchild))
				return OK;
		return ERROR;

	}
	else
		return OK;
}

Status LeafCount(BiTree T)
{
	if (T)
	{
		if (T->lchild == NULL&&T->rchild == NULL)
		{
			cout << T->data;
			Count++;
		}
		if (LeafCount(T->lchild))
			if (LeafCount(T->rchild))
				return OK;
		return ERROR;
	}
	else
		return OK;
}

/*
交换二叉树中所有节点的左右子树
*/
Status ExchangeBiTree(BiTree &T)
{
	BiTree p;
	if (T)
	{
		if (T->lchild || T->rchild) {
			p = T->lchild;
			T->lchild = T->rchild;
			T->rchild = p;
		}
		if (ExchangeBiTree(T->lchild))
			if (ExchangeBiTree(T->rchild))
				return OK;
		return ERROR;
	}
	else
		return OK;
}

Status CopyBiTree(BiTree T, BiTree &B)
{
	if (T == NULL)
		B = NULL;
	else
	{
		if (!(B = (BiTNode *)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		B->data = T->data;
		CopyBiTree(T->lchild, B->lchild);
		CopyBiTree(T->rchild, B->rchild);
	}
	return OK;
}

Status DestroyTree(BiTree &T)
{
	if (T)
	{
		DestroyTree(T->lchild);
		DestroyTree(T->rchild);
		free(T);
	}
	return OK;
}

Status ClearTree(BiTree &T)
{
	if (T)
	{
		T = NULL;
	}
	return OK;
}

int Depth(BiTree T)
{
	int leftDepth, rightDepth;
	if (T == NULL)
		return 0;
	else
	{
		leftDepth = Depth(T->lchild);
		rightDepth = Depth(T->rchild);
		if (leftDepth >= rightDepth)
			return leftDepth + 1;
		else
			return rightDepth + 1;
	}
}

void main()
{
	BiTree T, B;
	cout << "创建二叉树，按先序次序输入二叉树中结点的值：" << endl;
	CreateBiTree(T);
	NodeCount(T);
	cout << "二叉树的结点个数为" << Nodenum << endl;
	cout << "二叉树的深度为：" << Depth(T) << endl;
	cout << "先序遍历二叉树，结果是：" << endl;
	PreOrderTraverse(T);
	cout << endl;
	cout << "中序遍历二叉树，结果是：" << endl;
	InOrderTraverse(T);
	cout << endl;
	cout << "后序遍历二叉树，结果是：" << endl;
	PostOrderTraverse(T);
	cout << endl;
	cout << "输出二叉树的叶子结点：" << endl;
	LeafCount(T);
	cout << endl;
	cout << "统计二叉树的叶子结点个数：" << Count << endl;
	cout << "交换二叉树中所有节点的左右子树！" << endl;
	ExchangeBiTree(T);
	if (CopyBiTree(T, B) == OK)
		cout << "成功复制二叉树T到二叉树B" << endl;
	if (DestroyTree(T) == OK)
		cout << "成功销毁二叉树T！" << endl;
	if (ClearTree(T) == OK)
		cout << "成功将二叉树T置为空树！" << endl;
	cout << "先序遍历二叉树B，结果是：" << endl;
	PreOrderTraverse(B);
	cout << endl;
	cout << "中序遍历二叉树B，结果是：" << endl;
	InOrderTraverse(B);
	cout << endl;
	cout << "后序遍历二叉树B，结果是：" << endl;
	PostOrderTraverse(B);
	cout << endl;
	system("pause");
}

非递归算法： 

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define maxSize 50
using namespace std;

typedef int Status;
typedef char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

int Nodenum = 0;
int Count = 0;//二叉树叶子结点统计

BiTree CreateBiTree()
{
	TElemType ch[maxSize];
	cin >> ch;
	int len = (int)strlen(ch);
	BiTree stack[maxSize];
	int top = -1;
	int i = 0;
	if (ch[i] == 0)
		return NULL;
	BiTree temp;
	BiTree root = new BiTNode();
	root->data = ch[i];
	root->lchild = NULL;
	root->rchild = NULL;
	stack[++top] = root;//根节点入栈
	i++;
	int flag = 1;//标志位：第一种情况：创建左孩子；2：创建右孩子；3：左右孩子均创建，出栈
	while (i < len)
	{
		BiTree pNew = NULL;
		if (flag == 1)//创建左孩子
		{
			/*
			'#'说明这是栈顶结点无左孩子，把标志位置2，判断右孩子
			*/
			if (ch[i] == '#')
			{
				
				flag = 2;
			}
			else
			{
				pNew = new BiTNode();
				pNew->data = ch[i];
				pNew->lchild = NULL;
				pNew->rchild = NULL;

				temp = stack[top];//取出当前栈顶
				temp->lchild = pNew;//当前结点为栈顶结点的左孩子
				stack[++top] = pNew;//当前结点入栈
				flag = 1;//使标志位初始化
			}
		}
		else if (flag == 2)//创建右孩子
		{
			/*
			栈顶结点无右孩子
			*/
			if (ch[i] == '#')
			{
				
				flag = 3;
			}
			else
			{
				/*
				与创建左孩子同理
				*/
				pNew = new BiTNode();
				pNew->data = ch[i];
				pNew->lchild = NULL;
				pNew->rchild = NULL;

				temp = stack[top];
				temp->rchild = pNew;
				stack[++top] = pNew;
				flag = 1;//置1继续判断结点的左孩子（左孩子优先）
			}
		}
		else//左右孩子都创建
		{
			temp = stack[top--];
			while (top > 0 && stack[top]->rchild == temp)
				--top;

			flag = 2;
			--i;
		}
		++i;
	}
	return root;
}
/*
先序遍历非递归算法
*/
void PreOrderTraverse(BiTree T)
{
	if (T)
	{
		BiTNode *Stack[maxSize];
		int top = -1;
		BiTNode *p;
		Stack[++top] = T;
		while (top != -1)
		{
			p = Stack[top--];
			cout << p->data;
			if (p->rchild != NULL)
				Stack[++top] = p->rchild;
			if (p->lchild != NULL)
				Stack[++top] = p->lchild;
		}
	}
}
/*
中序遍历的非递归算法
*/
void InOrderTraverse(BiTree T)
{
	
	if (T)
	{
		BiTNode *Stack[maxSize];
		int top = -1;
		BiTNode *p = T;
		while (top != -1 || p != NULL)
		{
			while (p != NULL)
			{
				Stack[++top] = p;
				p = p->lchild;
			}
			if (top != -1)
			{
				p = Stack[top--];
				cout << p->data;
				p = p->rchild;
			}
		}
	}	
}

/*
后序遍历的非递归算法
*/

void PostOrderTraverse(BiTree T)
{
	if (T)
	{
		BiTNode *Stack1[maxSize];
		int top1 = -1;
		BiTNode *Stack2[maxSize];
		int top2 = -1;
		BiTNode *p = NULL;
		Stack1[++top1] = T;
		while (top1 != -1)
		{
			p = Stack1[top1--];
			Stack2[++top2] = p;
			if (p->lchild!=NULL)
				Stack1[++top1] = p->lchild;
			if (p->rchild != NULL)
				Stack1[++top1] = p->rchild;
		}
		while (top2 != -1)
		{
			p = Stack2[top2--];
			cout << p->data;
		}
	}
	
}
/*
层次遍历非递归算法
*/
void level(BiTree T)
{
	int front, rear;
	BiTNode *queue[maxSize];//队列先进先出
	front = rear = 0;
	BiTNode *q;
	if (T != NULL)
	{
		rear = (rear + 1) % maxSize;//循环队列，避免越界
		queue[rear] = T;//首节点结点插入队尾
		while (front != rear)//说明队列中尚有结点
		{
			front = (front + 1) % maxSize;//避免越界
			q = queue[front];//队头结点出队
			cout << q->data;
			/*
			判断左右孩子，左孩子先进队列
			*/
			if (q->lchild != NULL)
			{
				rear = (rear + 1) % maxSize;
				queue[rear] = q->lchild;
			}
			if (q->rchild != NULL)
			{
				rear = (rear + 1) % maxSize;
				queue[rear] = q->rchild;
			}
		}
	}

}

Status NodeCount(BiTree T)
{
	if (T)
	{
		Nodenum++;
		if (NodeCount(T->lchild))
			if (NodeCount(T->rchild))
				return OK;
		return ERROR;

	}
	else
		return OK;
}
/*
   原理和层次遍历相同，稍作修改加个判断条件：
       此结点左右孩子是否为空，是则输出，不是则判断下一个
*/
void LeafCount(BiTree T)
{
	int front, rear;
	BiTNode *queue[maxSize];//队列先进先出
	front = rear = 0;
	BiTNode *q;
	if (T != NULL)
	{
		rear = (rear + 1) % maxSize;//循环队列，避免越界
		queue[rear] = T;//首节点结点插入队尾
		while (front != rear)//说明队列中尚有结点
		{
			front = (front + 1) % maxSize;//避免越界
			q = queue[front];//队头结点出队
			/*
			判断左右孩子，左孩子先进队列
			*/
			if (q->lchild != NULL)
			{
				rear = (rear + 1) % maxSize;
				queue[rear] = q->lchild;
			}
			if (q->rchild != NULL)
			{
				rear = (rear + 1) % maxSize;
				queue[rear] = q->rchild;
			}
			if (q->lchild == NULL&&q->rchild == NULL)
			{
				cout << q->data;
				Count++;
			}
		}
	}
}

/*
交换二叉树中所有节点的左右子树:
(非递归）
     第一步：层次遍历：入队列
	 第二步：交换每个结点的左右子树
*/
void ExchangeBiTree(BiTree &T)
{
	if (T)
	{
		BiTNode *temp;
		BiTNode *p;
		int front, rear;
		front = rear = 0;
		BiTNode *queue[maxSize];
		if (T != NULL)
		{
			rear = (rear + 1) % maxSize;//循环队列，避免越界
			queue[rear] = T;//首节点结点插入队尾
			while (front != rear)//说明队列中尚有结点
			{
				front = (front + 1) % maxSize;//避免越界
				p = queue[front];//队头结点出队
				/*
				判断左右孩子，左右孩子进队列
				*/
				if (p->lchild != NULL)
				{
					rear = (rear + 1) % maxSize;
					queue[rear] = p->lchild;
				}
				if (p->rchild != NULL)
				{
					rear = (rear + 1) % maxSize;
					queue[rear] = p->rchild;
				}

				temp = p->lchild;
				p->lchild = p->rchild;
				p->rchild = temp;
			}
		}
	}
}

Status CopyBiTree(BiTree T, BiTree &B)
{
	if (T == NULL)
		B = NULL;
	else
	{
		if (!(B = (BiTNode *)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		B->data = T->data;
		CopyBiTree(T->lchild, B->lchild);
		CopyBiTree(T->rchild, B->rchild);
	}
	return OK;
}
/*
    销毁二叉树
*/
Status DestroyTree(BiTree &T)
{
	if (T)
	{
		DestroyTree(T->lchild);
		DestroyTree(T->rchild);
		free(T);
	}
	return OK;
}
/*
   清空二叉树
*/
Status ClearTree(BiTree &T)
{
	if (T)
	{
		T = NULL;
	}
	return OK;
}
/*
   求二叉树的深度(非递归算法）：（层次遍历）
*/
int Depth(BiTree T)
{
	int level = 0;//层次
	if (T)
	{
		int front = 0, rear = 0;
	BiTNode *Queue[maxSize]; 
	Queue[rear++] = T;
	
			
	while (front!=rear)
	{
		int len = rear - front;
		level++;
		while (len--)
		{
			BiTNode *temp = Queue[front];
			front++;
			if (temp->lchild)
				Queue[rear++] = temp->lchild;
			if (temp->rchild)
				Queue[rear++] = temp->rchild;
		}
	}					
	}


	return level;
}

void main()
{
	BiTree T, B;
	cout << "创建二叉树，按先序次序输入二叉树中结点的值：" << endl;
	T=CreateBiTree();
	NodeCount(T);
	cout << "二叉树的结点个数为" << Nodenum << endl;
	cout << "二叉树的深度为：" << Depth(T) << endl;
	cout << "先序遍历二叉树，结果是：" << endl;
	PreOrderTraverse(T);
	cout << endl;
	cout << "中序遍历二叉树，结果是：" << endl;
	InOrderTraverse(T);
	cout << endl;
	cout << "后序遍历二叉树，结果是：" << endl;
	PostOrderTraverse(T);
	cout << endl;
	cout << "层次遍历二叉树，结果是：" << endl;
	level(T);
	cout << endl;
	cout << "输出二叉树的叶子结点：" << endl;
	LeafCount(T);
	cout << endl;
	cout << "统计二叉树的叶子结点个数：" << Count << endl;
	cout << "交换二叉树中所有节点的左右子树！" << endl;
	ExchangeBiTree(T);
	if (CopyBiTree(T, B) == OK)
		cout << "成功复制二叉树T到二叉树B" << endl;
	if (DestroyTree(T) == OK)
		cout << "成功销毁二叉树T！" << endl;
	if (ClearTree(T) == OK)
		cout << "成功将二叉树T置为空树！" << endl;
	cout << "先序遍历二叉树B，结果是：" << endl;
	PreOrderTraverse(B);
	cout << endl;
	cout << "中序遍历二叉树B，结果是：" << endl;
	InOrderTraverse(B);
	cout << endl;
	cout << "后序遍历二叉树B，结果是：" << endl;
	PostOrderTraverse(B);
	cout << endl;
	system("pause");
}

阿基美德
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建二叉树的非递归算法实现
m0_37546257的博客
10-27 1074
非递归创建二叉树（中序）算法核心思路： 1）从根节点到左子树的叶子节点（创建节点、节点压栈）； 2）记录每个节点的状态分三种情况：初始状态、左子树建立完成状态、右子树建立完成状态； 3）左右子树创建完成之后向上返回（出栈直到栈为空）； 具体代码如下： binary_tree.h #ifndef _BINARY_TREE_H #define _BINARY_TREE_H #include <stdio.h> #include <stdlib.h> #include <strin
数据结构——二叉树的非递归遍历
qq_42106610的博客
11-01 1234
二叉树的非递归遍历，主要难点在于后序遍历。当出栈结点同时具有左右子树时需要判别遍历路经，确定是否已遍历右子树，遍历过右子树后再遍历根结点。
二叉树的创建——递归与非递归
最新发布
ting_happy的博客
11-05 1009
初学者对于二叉树的遍历，这些放在最早学习的内容，应该是非常熟悉的，但是渐渐的就会发现，对于如何创建一颗二叉树，初学者对此过程还不甚清晰。直接一个一个结点插入吗？当树的深度过大时，这显然是一个费时费力的过程。以下我们介绍二叉树的创建的两种方法——递归与非递归。
非递归创建二叉树
专注技术
11-15 6094
文章目录二叉树的非递归创建【算法原理】 二叉树的非递归创建 【算法原理】 利用栈先进后出的特点及栈的相关操作，再加上标记数组，完成二叉树的非递归创建。 注意： 1.顺序栈：a数组用来存每个树节点（tree类型），tag数组（int类型）是标记数组，用来非递归建树和非递归后序遍历。top，始终指向当前栈中元素的下一个位置。 2.标记：0表示没有左子树，1表示左子树已经创建，2表示左右子树都已创...
非递归法创建二叉树
ljk的博客
12-04 3308
非递归法创建二叉树 层次遍历二叉树
二叉树的遍历——递归以及非递归实现
06-03
vs2010下运行编写，使用了STL栈，实现了基本的插入、删除、计算深度、查找，主要是遍历，包括递归遍历，以及非递归的前序中序后序遍历，每个函数都有测试用例，如果存在错误，请在给我留言。
数据结构实验——二叉树的建立和遍历.zip
12-13
2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1...
遍历二叉树的4个非递归算法.rar_binary tree_二叉树_二叉树 非递归 遍历_递归_遍历 CSharp
09-14
二叉树遍历是理解和操作二叉树的关键技能，通常包括三种主要的递归方法：前序遍历、中序遍历和后序遍历，以及一种非递归方法——层次遍历。本资源"遍历二叉树的4个非递归算法.rar"提供了C#语言实现的这四种非递归...
二叉树遍历递归与非递归（C语言版）
05-30
在给定的文件中，`BiTreeTraverse.h`可能包含了遍历函数的声明，`Queue.h`可能提供了队列结构用于非递归遍历的实现，`BiTree.h`包含了二叉树节点的定义，`SeqStack.h`提供了顺序栈的定义，而`二叉树.cpp`则包含了...
c++实现二叉树的4种遍历（递归和非递归）（csdn）————程序.pdf
12-01
对于每种遍历方法，都有递归和非递归两种实现方式。例如，前序遍历的递归实现如下： ```cpp void PreOrderTraverse(BiTNode *T) { if (T == nullptr) { return; } cout << T->val; PreOrderTraverse(T->left); ...
C++ 非递归二叉树创建
07-09
非递归实现C++二叉树 Node* creatTree(struct Node *head) void preOrderUnrec(struct Node *head) void inOrderUnrec(struct Node *head) void postOrderUnrec(struct Node *head)
二叉树的创建与三种遍历的递归与非递归实现
06-09
二叉树的创建与三种遍历的递归与非递归实现 包括二叉树的动态创建，前序遍历，中序遍历，后续遍历的递归与非递归方法的实现。
二叉树的创建和各种遍历递归和非递归
01-12
二叉树的基本操作，C语言编码，包括二叉树的创建，非递归先序中序和后序遍历，叶子结点的数目以及求树的高度
对于二叉树的非递归遍历（非常好记的三种方式）
foreveyking的博客
03-27 8342
显然，我们需要用一个stack来模拟递归时的函数调用。对于三种遍历，我们都使用push当前节点-&gt;push左子树-&gt;pop左子树-&gt;push右子树-&gt;pop右子树的方式。但是cout时机会有所不同。对于前序遍历来说，每次访问到一个节点就cout；对于中序遍历来说，每次将右子节点进栈时，把当前节点cout；对于后序遍历来说，每次pop的时候cout。另外我们还需要一个last...
二叉树的非递归建立（一）
小僧Coding
06-05 4803
我们参照递归过程中栈的变化情况适用堆栈来解决 。首先将二叉树进行扩展 ，如下图所示 ： 然后按先序遍历的顺序输入节点的信息 ，根据输入的信息设置一个标志位 flag, 并初始化为1。 flag = 1表示现在需要创建当前节点的左孩子，flag = 2表示需要创建右孩子，flag = 3则表示当前节点的左右孩子都已经创建完毕，需要执行出栈操作，直到出栈节点不是当前栈顶节点的右孩子为止。 具体如下
二叉树中序遍历非递归算法实现详解
jin的专栏
05-22 1万+
二叉树是数据结构中的经典结构，也是应用很广泛的结构之一。二叉树具有一些特定的性质，如 n0 = n2+1，在一些应用中，常常要求在树中查找具有某些特征的节点，或者对树中节点进行处理，即遍历二叉树的问题，其递归算法非常容易实现，非递归算法也有两种思路，本文将在程序中实现笔者认为容易识记的一种方法。
C#--二叉树的遍历（递归和非递归）
qq826364410的专栏
03-01 2163
二叉树的遍历 包含四种遍历方式： 前序遍历 中序遍历 后序遍历 层次遍历 一.前序遍历 前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。 1.递归实现 // 前序遍历：首先访问根结点，然后遍历其左子树，最后遍历其右子树。 private void PreOrder(TreeNode<T> node) { if (nod...
图——有向图、无向图、有向网、无向网的邻接矩阵表示
热门推荐
阿基美德的博客
06-03 1万+
图的邻接矩阵表示

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值