二叉树遍历及树类型的判断

最新推荐文章于 2024-05-01 22:08:34 发布
最新推荐文章于 2024-05-01 22:08:34 发布
阅读量332 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18668139/article/details/107634621
版权

二叉树遍历及树类型的判断

内容：树定义,前、中、后 、层次遍历，树的高度，判断树是否平衡、是否是二叉搜索树、是否是AVL树、两棵树是否同构

一. 定义

typedef struct TNode *PtrToTNode;
typedef PtrToTNode BinTree;
struct TNode{
	TElemType data;
	BinTree left;
	BinTree right;
};

二. 树的基本操作

2.1 树的创建

BinTree CreateBinTree(){
	BinTree T;
	int i;
	
	scanf("%d", &i);
	if(i == -1) 
		T = NULL;
	else{
		T = (BinTree)malloc(sizeof(struct TNode));
		T->data = i;
		printf("请输入左孩子：如果为空输入-1\n");
		T->left = CreateBinTree();
		printf("请输入右孩子：如果为空输入-1\n");
		T->right = CreateBinTree();
	}	
	return T;
}

2.2 遍历

2.2.1 前、中、后、层次遍历

递归版本
void PreOrder(BinTree T){
	if(T){
		printf("%d ",T->data);
		PreTravel(T->left);
		PreTravel(T->right);
	}
}

void InOrder(BinTree T){
	if(T){
		InTraverl(T->left);
		printf("%d ",T->data);
		InTraverl(T->right);
	}
}

void PostOrder(BinTree T){
	if(T){
		PostTravel(T->left);
		PostTravel(T->right);
		printf("%d ",T->data);
	}
}

void LevelOrder(BinTree T){
	Queue Q;
	PtrToTNode tmpNode;
	
	if(!T) return;
	
	Q = CreateQueue();
	Add(Q,T);
	while(!IsEmpty(Q)){
		tmpNode = Delete(Q);
		printf("%d ", tmpNode->data);
		if(tmpNode->left) Add(Q, tmpNode->left);
		if(tmpNode->right) Add(Q, tmpNode->right);
	}
}
非递归版本

前、中、后序遍历

void PreOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Visit(p);
			Push(S, p);
			p = p->left;
		}
		else {
			p = Pop(S);
			p = p->right;
		}
	}
}

void InOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Push(S, p);
			p = p->left;
		}
		else {
			p = Pop(S);
			Visit(p);
			p = p->right;
		}
	}
}

void PostOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T, r = NULL;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Push(S, p);
			p = p->left;
		}
		else {
			p = GetTop(S);
			if (p->right && p->right != r) {
				p = p->right;
			}
			else {
				p = Pop(S);
				Visit(p);
				r = p;
				p = NULL;
			}
		}
	}
}

2.3 获得树的高度

int GetHeight(BinTree T){
	int a , b;
	if(!T)return 0;
	a = GetHeight(T->left);
	b = GetHeight(T->right);
	
	return Max(a,b) + 1;
}

三. 判断树的类型

3.1 判断是否平衡

注意：这里是仅为判断树是否平衡，而非判断是否是平衡二叉树
一开始我写的时候以为只要是高度平衡了就是AVL树，但是后面复习到AVL树的时候就想起来：

  • 平衡二叉树是平衡的二叉搜索树，对于任意一个节点，其左子树所有节点必须小于当前节点，右子树上所有节点必须都大于当前节点
int IsAverage(BinTree T){
	int a, b;
	int balanceFactor;
	if(!T) return TRUE;
	
	a = IsAverage(T->left);
	b = IsAverage(T->right);
	if(a == FALSE || b == FALSE)
		return FALSE;
	
	balanceFactor = GetBalanceFactor(T->left, T->right);
	return (balanceFactor >= 2) || (balanceFactor <= -2) ? FALSE : TRUE;
}

3.2 判断是否为二叉排序树

int IsBinSearchTree(BinTree T){
	BinTree tmpTree,tmpTree2;
	
	if(!T) return TRUE;
	if(IsBinSearchTree(T->left) == FALSE || IsBinSearchTree(T->right) == FALSE)
		return FALSE;
	if(NULL == T->left && NULL == T->right){ 
	//左右子树都为NULL
	//则当前节点为根的树平衡，返回TRUE
		return TRUE;
	} else if(NULL == T->left && NULL != T->right){
	//左子树为NULL，右子树非空
		tmpTree = FindMin(T->right);
		if(T->data <= tmpTree->data)
			return TRUE;
		else
			return FALSE;
	}else if(NULL != T->left && NULL == T->right){
	//左子树非空，右子树为NULL
		tmpTree = FindMax(T->left);
		if(T->data >= tmpTree->data)
			return TRUE;
		else
			return FALSE;
	}else{
	//左右子树皆非空
		tmpTree = FindMax(T->left);
		tmpTree2 = FindMin(T->right);
		if(tmpTree->data <= T->data && T->data <= tmpTree2->data)
			return TRUE;
		else
			return FALSE;
	}
}

3.3 判断是否为平衡二叉树

3.3.1 平衡二叉树的条件

  • 是二叉搜索树
  • 树平衡
int IsAVLTree(BinTree T){
	if(IsBinSearchTree(T) && IsAverage(T))
		return TRUE;
	return FALSE;
}

3.4 判断两棵树结构是否相同（同构）

3.4.1 递归

int IsSameStruct(BinTree T1, BinTree T2){
	/*if(T1 == NULL && T2 == NULL)
		return TRUE;
	if(T1 == NULL || T2 == NULL)
		return FALSE;*/
	//上述式子可以简化为如下 
	if(T1 == NULL || T2 == NULL) return T2 == NULL;	
	
	return IsSameStruct(T1->left, T2->left) && IsSameStruct(T1->right, T2->right);
}

3.4.2 非递归

int IsSameStruct2(BinTree T1, BinTree T2){
	Queue Q1,Q2;
	BinTree p, q;
	
	Q1 = CreateQueue();
	Q2 = CreateQueue();
	
	Add(Q1,T1);
	Add(Q2,T2);
	
	while(IsEmpty(Q1) == FALSE && IsEmpty(Q2) == FALSE){
		p = Delete(Q1);
		q = Delete(Q2);
		
		if(p != NULL && q != NULL){
			if(p->left == NULL && q->left == NULL){
			//两右子树都为NULL的情况不做处理 
			}else if(p != NULL || q != NULL){
				//有一颗子树为空 
				return FALSE;
			}else{
			//两左子树全部非空 
				Add(Q1, p->left);
				Add(Q2, p->left);
			}
			
			if(p->right == NULL && q->right == NULL){
			//两右子树都为NULL的情况不做处理 
			}else if( p != NULL || q != NULL){
			//有一颗子树为空 
				return FALSE;
			}else{
			//两左子树全部非空 
				Add(Q1, p->right);
				Add(Q2, q->right);
			}
		}else if(T1 != NULL || T2 != NULL){
			return FALSE;
		}else{
			//T1，T2都为NULL的情况不作处理 
		}
	}
	
	//整棵树遍历完了之后没有返回FALSE，则返回TRUE
	return TRUE; 
}

附完整代码

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

#define MAXSIZE 100
#define FALSE 0
#define TRUE 1
#define OVERFLOW -1

typedef int TElemType;//----------------->TElemType

typedef struct TNode* PtrToTNode;
typedef PtrToTNode BinTree;
struct TNode {
	TElemType data;
	BinTree left;
	BinTree right;
};

typedef BinTree QElemType;//-------------->QElemType 
typedef struct QNode* PtrToQNode;
struct QNode {
	QElemType* elem;
	int front;
	int rear;
};
typedef PtrToQNode Queue;


/*----------------------------Queue--------------------------------------------*/
Queue CreateQueue() {
	Queue Q;
	Q = (Queue)malloc(sizeof(struct QNode));
	Q->elem = (QElemType*)malloc(sizeof(QElemType) * MAXSIZE);
	Q->front = Q->rear = 0;
	return Q;
}

int IsFull(Queue Q) {
	return (Q->rear + 1) % MAXSIZE == Q->front;
}

void Add(Queue Q, QElemType elem) {
	//if(elem == NULL) return; 
	if (IsFull(Q)) {
		printf("队列已满！\n");
		exit(0);
	}
	Q->elem[Q->rear] = elem;
	Q->rear = (Q->rear + 1) % MAXSIZE;
}

int IsEmpty(Queue Q) {
	return Q->front == Q->rear;
}

QElemType Delete(Queue Q) {
	QElemType temp;
	if (IsEmpty(Q)) {
		printf("队列已空！\n");
		exit(0);
	}
	temp = Q->elem[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return temp;
}

/*----------------------------Stack---------------------------------------*/
typedef BinTree ElemType;
typedef struct SNode* PtrToSNode;
struct SNode {
	ElemType data;
	PtrToSNode next;
};
typedef PtrToSNode Stack;

Stack CreateStack() {
	Stack S;
	S = (Stack)malloc(sizeof(struct SNode));
	S->next = NULL;
	return S;
}

int IsStackEmpty(Stack S) {
	return S->next == NULL;
}

int Push(Stack S, ElemType elem) {
	PtrToSNode tmpCell;
	tmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
	if (!tmpCell) exit(OVERFLOW);
	tmpCell->data = elem;
	tmpCell->next = S->next;
	S->next = tmpCell;
	return TRUE;
}

ElemType Pop(Stack S) {
	PtrToSNode firstCell;
	ElemType tmp;
	if (IsStackEmpty(S)) {
		printf("Stack is empty !\n");
		exit(FALSE);
	}
	else {
		firstCell = S->next;
		S->next = firstCell->next;
		tmp = firstCell->data;
	}
	free(firstCell);
	return tmp;
}

ElemType GetTop(Stack S) {
	if (!IsStackEmpty(S))
		return S->next->data;
	else {
		printf("The stack is empty ! \n");
		return 0;
	}
}

/*---------------------------Tree------------------------------------------*/
BinTree CreateBinTree() {
	BinTree T;
	int i;

	scanf("%d", &i);
	if (i == -1)
		T = NULL;
	else {
		T = (BinTree)malloc(sizeof(struct TNode));
		T->data = i;
		printf("请输入左孩子：如果为空输入-1\n");
		T->left = CreateBinTree();
		printf("请输入右孩子：如果为空输入-1\n");
		T->right = CreateBinTree();
	}
	return T;
}
void Visit(BinTree T) {
	if (!T)return;
	printf("%d ", T->data);
}
void PreOrder(BinTree T) {
	if (T) {
		Visit(T);
		PreTravel(T->left);
		PreTravel(T->right);
	}
}

void InOrder(BinTree T) {
	if (T) {
		InTravel(T->left);
		Visit(T);
		InTravel(T->right);
	}
}

void PostTOrder(BinTree T) {
	if (T) {
		PostTravel(T->left);
		PostTravel(T->right);
		Visit(T);
	}
}

void LevelOrder(BinTree T) {
	Queue Q;
	PtrToTNode tmpNode;

	if (!T) return;

	Q = CreateQueue();
	Add(Q, T);
	while (!IsEmpty(Q)) {
		tmpNode = Delete(Q);
		Visit(tmpNode);
		if (tmpNode->left) Add(Q, tmpNode->left);
		if (tmpNode->right) Add(Q, tmpNode->right);
	}
}

/*-------------------以下为非递归前、中、后序遍历--------------------*/
void PreOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Visit(p);
			Push(S, p);
			p = p->left;
		}
		else {
			p = Pop(S);
			p = p->right;
		}
	}
}

void InOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Push(S, p);
			p = p->left;
		}
		else {
			p = Pop(S);
			Visit(p);
			p = p->right;
		}
	}
}

void PostOrder2(BinTree T) {
	Stack S = CreateStack();
	BinTree p = T, r = NULL;
	while (p || !IsStackEmpty(S)) {
		if (p) {
			Push(S, p);
			p = p->left;
		}
		else {
			p = GetTop(S);
			if (p->right && p->right != r) {
				p = p->right;
			}
			else {
				p = Pop(S);
				Visit(p);
				r = p;
				p = NULL;
			}
		}
	}
}

/*----------------------------判断树的类型----------------------------------------*/
int Max(int a, int b) {
	return a > b ? a : b;
}

int GetHeight(BinTree T) {
	int a, b;
	if (!T)return 0;
	a = GetHeight(T->left);
	b = GetHeight(T->right);

	return Max(a, b) + 1;
}

int GetBalanceFactor(BinTree T1, BinTree T2) {
	return GetHeight(T1) - GetHeight(T2);
}

BinTree FindMin(BinTree T) {
	if (!T) return NULL;
	while (T->left)
		T = T->left;
	return T;
}

BinTree FindMax(BinTree T) {
	if (!T) return NULL;
	while (T->right)
		T = T->right;
	return T;
}

/*------------------判断树是否平衡  注：并非判断是否为平衡二叉树 ---------------*/
int IsAverage(BinTree T) {
	int a, b;
	int balanceFactor;
	if (!T) return TRUE;

	a = IsAverage(T->left);
	b = IsAverage(T->right);
	if (a == FALSE || b == FALSE)
		return FALSE;

	balanceFactor = GetBalanceFactor(T->left, T->right);
	return (balanceFactor >= 2) || (balanceFactor <= -2) ? FALSE : TRUE;
}

/*--------------------------判读是否是二叉排序树------------------------------*/
int IsBinSearchTree(BinTree T) {
	BinTree tmpTree, tmpTree2;

	if (!T) return TRUE;
	if (IsBinSearchTree(T->left) == FALSE || IsBinSearchTree(T->right) == FALSE)
		return FALSE;
	if (NULL == T->left && NULL == T->right) {
		//左右子树都为NULL
		//则当前节点为根的树平衡，返回TRUE
		return TRUE;
	}
	else if (NULL == T->left && NULL != T->right) {
		//左子树为NULL，右子树非空
		tmpTree = FindMin(T->right);
		if (T->data <= tmpTree->data)
			return TRUE;
		else
			return FALSE;
	}
	else if (NULL != T->left && NULL == T->right) {
		//左子树非空，右子树为NULL
		tmpTree = FindMax(T->left);
		if (T->data >= tmpTree->data)
			return TRUE;
		else
			return FALSE;
	}
	else {
		//左右子树皆非空
		tmpTree = FindMax(T->left);
		tmpTree2 = FindMin(T->right);
		if (tmpTree->data <= T->data && T->data <= tmpTree2->data)
			return TRUE;
		else
			return FALSE;
	}
}

/*-------------------------判断是否是AVL树---------------------------*/
int IsAVLTree(BinTree T) {
	if (IsBinSearchTree(T) && IsAverage(T))
		return TRUE;
	return FALSE;
}

/*-------------------------判断是否同构-------------------------------*/
//递归 
int IsSameStruct(BinTree T1, BinTree T2) {
	/*if(T1 == NULL && T2 == NULL)
		return TRUE;
	if(T1 == NULL || T2 == NULL)
		return FALSE;*/
		//上述式子可以简化为如下 
	if (T1 == NULL || T2 == NULL) return T2 == NULL;

	return IsSameStruct(T1->left, T2->left) && IsSameStruct(T1->right, T2->right);
}

//非递归
int IsSameStruct2(BinTree T1, BinTree T2) {
	Queue Q1, Q2;
	BinTree p, q;

	Q1 = CreateQueue();
	Q2 = CreateQueue();

	Add(Q1, T1);
	Add(Q2, T2);

	while (IsEmpty(Q1) == FALSE && IsEmpty(Q2) == FALSE) {
		p = Delete(Q1);
		q = Delete(Q2);

		if (p != NULL && q != NULL) {
			if (p->left == NULL && q->left == NULL) {
				//两右子树都为NULL的情况不做处理 
			}
			else if (p != NULL || q != NULL) {
				//有一颗子树为空 
				return FALSE;
			}
			else {
				//两左子树全部非空 
				Add(Q1, p->left);
				Add(Q2, p->left);
			}

			if (p->right == NULL && q->right == NULL) {
				//两右子树都为NULL的情况不做处理 
			}
			else if (p != NULL || q != NULL) {
				//有一颗子树为空 
				return FALSE;
			}
			else {
				//两左子树全部非空 
				Add(Q1, p->right);
				Add(Q2, q->right);
			}
		}
		else if (T1 != NULL || T2 != NULL) {
			return FALSE;
		}
		else {
			//T1，T2都为NULL的情况不作处理 
		}
	}

	//整棵树遍历完了之后没有返回FALSE，则返回TRUE
	return TRUE;
}

int main() {
	BinTree T1, T2;
	T1 = CreateBinTree();
	/*printf("下面请输入第二棵树的信息：\n");
	T2 = CreateBinTree();*/
	/*
	LevelTravel(T);
	printf("\nThe height is: %d\n", GetHeight(T));
	if(IsAverage(T)){
		printf("The tree is Average !\n");
	}else{
		printf("The tree is not Average !\n");
	}
	if(IsBinSearchTree(T)){
		printf("The tree is BinSearchTree !\n");
	}else{
		printf("The tree is not BinSearchTree !\n");
	}

	if(IsAVLTree(T))
		printf("The tree is AVLTree ! \n");
	else
		printf("The tree is not AVLTree ! \n");
	*/

	printf("前序遍历：");
	PreOrder2(T1);

	printf("\n中序遍历：");
	InOrder2(T1);

	printf("\n后序遍历：");
	PostOrder2(T1);

	printf("\n层次遍历：");
	LevelTravel(T1);


	/*
	if(IsSameStruct2(T1, T2))
		printf("同构\n");
	else
		printf("不同构\n");
		*/
}
海绵宝宝我是派大星
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的构建，遍历和判断
qq_43411555的博客
11-15 280
树是一个重要的数据结构，在很多情况下都会用到，今天给大家分享树的构建，遍历和判断，主要实现有： 根据先序和中序构建二叉树 根据后序和中序构建二叉树 先序非递归遍历 中序非递归遍历 后序非递归遍历 层次非递归遍历 判断二叉树是否为完全二叉树 判断二叉树是否为满二叉树 判断二叉树是否为平衡二叉树 相关的思路在代码中已注释，具体如下： # include <iostream> using...
中序遍历树并判断是否为二叉搜索树
hhxcy的博客
04-16 2751
对给定的有N个节点（N>=0）的二叉树，给出中序遍历序列，并判断是否为二叉搜索树。 题目保证二叉树不超过200个节点，节点数值在整型int范围内且各不相同。 输入格式: 第一行是一个非负整数N，表示有N个节点 第二行是一个整数k，是树根的元素值 接下来有N-1行，每行是一个新节点，格式为r d e 三个整数， r表示该节点的父节点元素值（保证父节点存在）；d是方向，0表示该节点为父节点的左儿...
数据结构 第五章 树和二叉树 作业（已批改）
Jessieeeeeee的博客
05-25 7737
知识点 判断题 1-1 There exists a binary tree with 2016 nodes in total, and with 16 nodes having only one child. // 存在一棵总共有2016个结点的二叉树，其中有16个结点只有一个孩子 T F 分析： 假设没有孩子的结点（叶结点）个数为n₀，只有一个孩子的结点（度为1的结点）个数为n₁，有两个孩子的结点（度为2的结点）个数为n₂。 则n₀+n₁+n₂=2016 ∵n₀=n₂+1（二叉树的性质：叶结点个
下列代码的功能是将二叉树T中的结点按照层序遍历的顺序输出
国家一级致癌物
12-12 3135
填空题 下列代码的功能是将二叉树T中的结点按照层序遍历的顺序输出。 typedef struct TreeNode* Tree; struct TreeNode { int Key; Tree Left; Tree Right; }; void Level_order(Tree T) { Queue Q; if (!T) return; Q = CreateQueue(MaxElements); Enqueue(T, Q); while
平衡二叉树代码实现（高效非递归方式）
最新发布
HSS521314的博客
05-01 469
【代码】平衡二叉树。
根据二叉树的遍历结果确定二叉树
m0_63223213的博客
07-24 1801
根据前序和中序遍历结果，后序和中序遍历结果求得唯一的二叉树并前序输出过程详解和完整代码
树的确定与遍历
smilesundream的博客
07-29 455
因为前序遍历、后续遍历都只能确定根的位置，无法确定左右子树的范围，因此这两者组合无法确定一棵树。
表达式的二叉树输入和该二叉树的遍历
nicehiro的博客
11-30 986
实现功能：输入一串表达式后，按照中序方式建立二叉树，并对其进行先序和后序的遍历。（输入表达式如此形式：a+b*c-d-e/f….；以#号结束。）程序的基本思想：输入：输入时直接输入表达式即可。（表达式中所有的符号仅为+，-，*，/，（，），）。 输出：输出时将输出二叉树的先序，中序，后序遍历结果。 判定表达式运算的运算符号的先后顺序；用 flag = 0 记作没有扫描到‘（‘，可以扫描括号外的运
二叉树的遍历
11-14
二叉树遍历是指按照特定顺序访问树中的每一个节点，通常有三种主要的遍历方式：前序遍历、中序遍历和后序遍历。 1. **前序遍历**：先访问根节点，然后递归地访问左子树，最后访问右子树。在给定的代码中，`preorder...
二叉树遍历插入节点
08-13
在实际应用中，二叉树遍历和插入节点的操作不仅限于基本的二叉树，还可以扩展到平衡二叉树（如AVL树、红黑树）或其他自定义类型的二叉树。这些操作在构建数据结构、实现算法、优化查询效率等方面都有着广泛的应用，...
二叉树的创建与遍历简介
11-15
例如，在算法竞赛或面试中，二叉树遍历是常见的题目类型。例如，你可能需要设计一个算法，给定一棵二叉树的前序遍历和中序遍历结果，重建原来的二叉树；或者给定一个序列，判断是否能形成一棵二叉搜索树。 二叉树的...
shujujiegou.rar_shujujiegou-erchashu_二叉树 建立 遍历_栈
09-19
在二叉树遍历中，栈的五种基本操作——置空栈、进栈、出栈、取栈顶元素、判栈空，扮演着关键角色。 先序遍历是二叉树遍历的一种，顺序为“根-左-右”。我们可以使用栈来实现：首先将根节点入栈，然后进入循环，每次...
C语言二叉树创建与遍历
12-24
C语言二叉树创建与遍历 二叉树是一种常用的数据结构，它由节点和边组成，每个节点最多有两个子节点，即左子节点和右子节点。在计算机科学中，二叉树广泛应用于各种场景，例如文件系统、数据库索引、编译器设计等。...
左神算法基础：判断二叉树的类别
TeddyZhang的博客
07-03 415
昨天的文章讲述了二叉树的先序、中序和后序的遍历方法（递归和非递归）,但是这种遍历方法有什么意义么？今天来讲讲这些算法可以用来做什么，只要稍加更改，我们就可以得到另外一个功能，只需要仅仅几行代码的修改！ 还记得上篇文章二叉树的分类么？今天我们要来说三种树的分类：完全二叉树、平衡二叉树和搜索二叉树！ 完全二叉树：只有最后一层不需要铺满，其余各层均是满的状态！ 平衡二叉树：每个节点的左子树和右子树的高度...
二叉树遍历判定
开挖掘机的博客
09-11 511
在数据结构中经常会遇到这样的题，给定一个二叉树的中序遍历和后序遍历，求先序遍历的结果。其实这样的题目是规律的，例如：中序遍历为：BCDJAFEGHI,后序遍历是：BJDCFGEIHA 分析：首先看后序的最后一个，这个便是根节点，然后在去中序中找到对应的节点A，即A在中序遍历结果分为两半，左边BCDJ是左子树，右边FEGHI是右子树，一直继续下去就可以得到一棵完整的树了。
判断二叉树后续遍历
happy_豆的博客
07-31 256
/* 输入一个整数数组，判断该数组是不是某二叉搜索树的后序 遍历的结果。如果是则输出Yes,否则输出No。假设输入的数 组的任意两个数字都互不相同。*/ //非递归 //非递归也是一个基于递归的思想： //左子树一定比右子树小，因此去掉根后，数字分为left，right两部分，right部分的 //最后一个数字是右子树的根他也比左子树所有值大，因此我们可以每次只看有子树是否符合条件 //即可，即使...
算法 二叉树的遍历、查找与判断
XXXTENTAC1ON的博客
05-06 533
二叉树的遍历非递归中序遍历非递归后续遍历非递归先序遍历二叉树层次遍历 非递归中序遍历 void NiceInOrder(BtNode* ptr) //非递归中序遍历 { if(ptr == nullptr) return; std::stack<BtNode*> st; while (ptr != nullptr || !st.empty()) { while (ptr != NULL) { st.push(ptr); ptr = ptr->leftchild
二叉树层序遍历、判断是否是完全二叉树
L_R
10-31 2927
二叉树的层序遍历 二叉树的层序遍历我们需要用到队列，先把根节点放进队列，当队首不为空时，取队首元素，Pop队列，打印队首元素，如果队首结点的左子树不为空，就把队首结点的左子树放到队列中，如果队首结点的右子树不为空，就把队首节点的右子树放到队列中。 void LevelOrder(BNode *root) { Queue queue; QueueInit(&amp;amp;amp;amp;queue); if (...
树——层序遍历
chenyang1004的博客
09-24 107
树——层序遍历 void LevelorderTraversal(BinTree BT) { Queue Q; BinTree T; if(!BT)return;/*若是空树直接返回*/ Q=CreatQueue();/*创建空队列Q*/ AddQ(Q,BT); while(!IsEmpty(Q)){ T=DeleteQ(Q); printf("%d",T->Data);/*访问取出队列的节点*/ if(T->Left) AddQ(Q,T->Left);
迭代器实现二叉树遍历：树结构与性质详解
二叉树遍历的迭代器类是二叉树算法中常用的一种高级数据结构模板，用于在树的节点之间进行遍历操作。在树的抽象数据类型（ADT）中，TreeIterator是一个模板类，它的主要作用是提供一种迭代方式来访问二叉树的节点，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值