二叉树的全部遍历实现与应用

最新推荐文章于 2022-09-01 06:00:00 发布
最新推荐文章于 2022-09-01 06:00:00 发布
阅读量1.3k 收藏 9
点赞数 5
分类专栏： C++ 文章标签： 二叉树 遍历 算法 应用 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012605514/article/details/42216195
版权

二叉树的遍历与应用

一、  实验目的

1. 熟练掌握二叉树的根前序、根中序、根后序遍历的递归和非递归的算法实现，并且能够从时间和空间复杂度的角度综合考虑递归和非递归算法的不同特点。

2. 二叉树是计算机科学中应用非常广泛的数据结构之一，通过对二叉树遍历算法的递归与非递归实现加深对二叉树的理解，并且学会用二叉树来解决实际中的简单问题。

3. 训练逻辑性的思维，通过对二叉树遍历算法问题的深入思考，加深对数据结构的认识。

4. 培养程序设计，算法分析以及调试程序的能力，为日后工作中参与项目打下基础。

 

二、  实验要求及实验环境

1. 实验要求

（1） 实现对二叉树的根前序、根中序、根后序遍历的递归和非递归以及层序遍历的不同算法；

（2） 给出二叉树的根前序和根中序，用递归算法和非递归算法分别建立二叉树。

（3） 对于二叉树的任意两个结点，给出这两个结点的最近公共祖先。

 

2．实验环境

   （1）操作系统：MicrosoftWindows 10 Technical Preview x64.

   （2）编译环境：Microsoft Visual Studio 2013 Ultimate.


三、  具体实现

1.数据结构实现

//二叉树的数据结构
struct BinaryTree
{
	char Data; //结点数据
	BinaryTree *LeftChild;//左子树
	BinaryTree *RightChild;//右子树
};
typedef BinaryTree *ROOT;


//实现非递归算法的工作栈
struct Stack
{
	BinaryTree *Data;
	Stack *Next;
	Stack() :Next(NULL){}
};
typedef Stack *STACK;


//实现非递归算法的辅助栈
struct AssistStack
{
	BinaryTree *NodePointer[NODENUMBERS];
	int Top;
};
typedef AssistStack *ATSTACK;


//实现层次遍历的队列
struct Queue
{
	int Front;
	int Rear;
	BinaryTree *Elements[NODENUMBERS];
};
typedef Queue *QUEUE;<strong>
</strong>


2. 功能函数

（1）前序递归遍历

/*递归前序遍历二叉树*/
void RecursionPreviousSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		VisitData(Root);
		RecursionPreviousSortErgodic(Root->LeftChild);
		RecursionPreviousSortErgodic(Root->RightChild);
	}
}

（2）前序非递归遍历

/*非递归前序遍历二叉树*/
void NonRecursionPreviousSortErgodic(ROOT &Root)
{
	STACK BinaryTreeStack;
	BinaryTreeStack = new Stack;

	StackMakeNull(BinaryTreeStack);

	struct BinaryTree *Node;
	Node = Root;
	while (Node != NULL)
	{
		VisitData(Node);
		if (Node->RightChild != NULL)
		{
			StackPush(Node->RightChild, BinaryTreeStack);
		}
		if (Node->LeftChild != NULL)
		{
			Node = Node->LeftChild; //进左子树
		}
		else
		{
			Node = StackTop(BinaryTreeStack);
			StackPop(BinaryTreeStack);	//做子树空，访问又子树
		}
	}
}

（3）中序递归遍历

/*递归中序遍历二叉树*/
void RecursionMiddleSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		RecursionMiddleSortErgodic(Root->LeftChild);
		VisitData(Root);
		RecursionMiddleSortErgodic(Root->RightChild);
	}
}

（4）中序非递归遍历

/*非递归中序遍历二叉树*/
void NonRecursionMiddleSortErgodic(ROOT &Root)
{
	STACK BinaryTreeStack;
	BinaryTreeStack = new Stack;
	StackMakeNull(BinaryTreeStack);

	struct BinaryTree *Node;
	Node = Root;

	while ((Node != NULL) || (!StackIsEmpty(BinaryTreeStack)))
	{
		while (Node != NULL)
		{
			StackPush(Node, BinaryTreeStack);
			Node = Node->LeftChild;
		}
		if (!StackIsEmpty(BinaryTreeStack))
		{
			Node = StackTop(BinaryTreeStack);
			StackPop(BinaryTreeStack);

			VisitData(Node);
			Node = Node->RightChild;
		}
	}
}

（5）后序递归遍历

/*递归后序遍历二叉树*/
void RecursionRearSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		RecursionRearSortErgodic(Root->LeftChild);
		RecursionRearSortErgodic(Root->RightChild);
		VisitData(Root);
	}
}

（6）后序非递归遍历

/*非递归后序遍历二叉树*/
void NonRecursionRearSortErgodic(ROOT &Root)
{
	ROOT Node;
	int Target[30];

	ATSTACK BinaryTreeStack;
	BinaryTreeStack = new AssistStack;
	AssistStackMakeNull(BinaryTreeStack);

	Node = Root;
	while (Node != NULL || !AssistStackIsEmpty(BinaryTreeStack))
	{
		while (Node != NULL)
		{
			AssistStackPush(Node, BinaryTreeStack);
			Target[BinaryTreeStack->Top] = -1;
			Node = Node->LeftChild;
		}
		while (!AssistStackIsEmpty(BinaryTreeStack) && Target[BinaryTreeStack->Top] == 1)
		{
			Node = AssistStackTop(BinaryTreeStack);
			AssistStackPop(BinaryTreeStack);
			VisitData(Node);
		}
		if (!AssistStackIsEmpty(BinaryTreeStack))
		{
			Target[BinaryTreeStack->Top] = 1;
			Node = AssistStackTop(BinaryTreeStack);
			Node = Node->RightChild;
		}
		else
		{
			break;
		}
	}
}

 

（7）层序遍历

//层次遍历二叉树
void LevelSortErgodic(ROOT &Root)
{
	ROOT Node;
	Node = Root;

	QUEUE Q;
	Q = new Queue;
	Q->Front = 0;
	Q->Rear = 0;

	if (Root == NULL)
	{
		return;
	}
	Q->Elements[++Q->Rear] = Root;
	while (Q->Front != Q->Rear)
	{
		Node = Q->Elements[++Q->Front];
		VisitData(Node);
		if (Node->LeftChild != NULL)
		{
			Q->Elements[++Q->Rear] = Node->LeftChild;
		}
		if (Node->RightChild != NULL)
		{
			Q->Elements[++Q->Rear] = Node->RightChild;
		}
	}
}



源代码

/**
*Copyright(C) 2014 HIT CS
*All rights reserved.

*Data and Struct Experiment 2 
*Create by Windows 8.1 Enterprise X64
*Edit and Compiled Visual Studio 2013 Ultimate
Version 1.2
Date 10/28/2014
*/

#define _CRT_SECURE_NO_WARNINGS

#define		NODENUMBERS		50

#include <iostream>
#include <string.h>

using namespace std;


//二叉树的数据结构
struct BinaryTree
{
	char Data; //结点数据
	BinaryTree *LeftChild;//左子树
	BinaryTree *RightChild;//右子树
};
typedef BinaryTree *ROOT;


//实现非递归算法的工作栈
struct Stack
{
	BinaryTree *Data;
	Stack *Next;
	Stack() :Next(NULL){}
};
typedef Stack *STACK;


//实现非递归算法的辅助栈
struct AssistStack
{
	BinaryTree *NodePointer[NODENUMBERS];
	int Top;
};
typedef AssistStack *ATSTACK;


//实现层次遍历的队列
struct Queue
{
	int Front;
	int Rear;
	BinaryTree *Elements[NODENUMBERS];
};
typedef Queue *QUEUE;


//对二叉树的操作函数
bool BinaryTreeIsEmpty(ROOT &Root);
char VisitData(ROOT &Root);


//对栈操作的函数
void StackMakeNull(STACK BinaryTreeStack);
void StackPush(BinaryTree *element, STACK BinaryTreeStack);
void StackPop(STACK BinaryTreeStack);
BinaryTree *StackTop(STACK BinaryTreeStack);
bool StackIsEmpty(STACK BinaryTreeStack);


//对辅助栈的操作函数
void AssistStackMakeNull(ATSTACK AssistStack);
void AssistStackPush(BinaryTree *Element, ATSTACK AssistStack);
BinaryTree *AssistStackTop(ATSTACK AssistStack);
void AssistStackPop(ATSTACK AssistStack);
bool AssistStackIsEmpty(ATSTACK AssistStack);


//由中序和前序序列生成测试二叉树的函数
void CreatTestBinaryTree(ROOT &Root);
int SearchPosition(char *MiddleSort, char element);
void PreMidCreatBinaryTree(ROOT &Root, char *Previous, int i, char *Middle, int j, int length); 


//功能函数
void MainChoiceMenu(ROOT &Root);
void GeneralListOut(ROOT &Root);
void RecursionPreviousSortErgodic(ROOT &Root); //递归前序遍历二叉树
void NonRecursionPreviousSortErgodic(ROOT &Root); //非递归前序遍历二叉树
void RecursionMiddleSortErgodic(ROOT &Root); //递归中序遍历二叉树
void NonRecursionMiddleSortErgodic(ROOT &Root); //非递归中序遍历二叉树
void RecursionRearSortErgodic(ROOT &Root); //递归后序遍历二叉树
void NonRecursionRearSortErgodic(ROOT &Root); //非递归后序遍历二叉树
void LevelSortErgodic(ROOT &Root); //层序遍历二叉树
BinaryTree* findLowestCommonAncestor(ROOT &Root, BinaryTree *a, BinaryTree *b); //寻找任意两个节点的公共祖先
BinaryTree *Search(ROOT &Root, char search);

int main()
{
	ROOT Root;
	MainChoiceMenu(Root);
	getchar();
	return 0;
}

//遍历操作选择菜单
void MainChoiceMenu(ROOT &Root)
{
	int choice;
	char a, b;
	BinaryTree *Node1, *Node2, *result;
	CreatTestBinaryTree(Root);

	do
	{
		cout << "\n\n\t二叉树遍历操作选择系统\n------------------------------------" << endl;
		cout << "  1.前序递归遍历二叉树" << endl;
		cout << "  2.前序非递归遍历二叉树" << endl;
		cout << "  3.中序递归遍历二叉树" << endl;
		cout << "  4.中序非递归遍历二叉树" << endl;
		cout << "  5.后序递归遍历二叉树" << endl;
		cout << "  6.后序非递归遍历二叉树" << endl;
		cout << "  7.层序遍历二叉树" << endl;
		cout << "  8.递归前序和后序建立二叉树结果广义表输出" << endl;
		cout << "  9.任意两个根的最近公共祖先" << endl;
		cout << "  0.退出系统" << endl;
		cout << " \n请选择:";
		cin >> choice;

		switch (choice)
		{
			case 0:
			{
				cout << "\n已退出系统\n" << "键入任意内容关闭" << endl;
				getchar();
				break;
			}
			case 1:
			{
				cout << "\n递归前序遍历二叉树结果：";
				RecursionPreviousSortErgodic(Root);
				break;
			}
			case 2:
			{
				cout << "\n非递归前序遍历二叉树结果：";
				NonRecursionPreviousSortErgodic(Root);
				break;
			}
			case 3:
			{
				cout << "\n递归中序遍历二叉树结果：";
				RecursionMiddleSortErgodic(Root);
				break;
			}
			case 4:
			{
				cout << "\n非递归中序遍历二叉树结果：";
				NonRecursionMiddleSortErgodic(Root);
				break;
			}
			case 5:
			{
				cout << "\n递归后序遍历二叉树结果：";
				RecursionRearSortErgodic(Root);
				break;
			}
			case 6:
			{
				cout << "\n非递归后序遍历二叉树结果：";
				NonRecursionRearSortErgodic(Root);
				break;
			}	
			case 7:
			{
				cout << "\n层序遍历二叉树结果：";
					  LevelSortErgodic(Root);
					  break;
			}
			case 8:
			{
				cout << "\n递归前序和后序建立二叉树结果广义表输出结果：";
				GeneralListOut(Root);
				break;
			}
			case 9:
			{
				cout << "\n寻找任意两个根的最近公共祖先\n-------------------------------" << endl;;
				cout << "输入两个节点(如A B):";
				cin >> a >> b;
				Node1 = Search(Root, a);
				Node2 = Search(Root, b);
				result = findLowestCommonAncestor(Root, Node1, Node2);
				cout << "\n节点 " << a << " 和 " << b << " 的公共祖先节点为： " << result->Data << endl;
				break;
			}
			default:
			{
				cout << "\n输入有误！" << endl;
			}
		}
	} 
	while (choice != 0);
}

//将建立的二叉树用广义表输出
void GeneralListOut(ROOT &Root)
{
	cout << Root->Data;
	if (Root->LeftChild != NULL || Root->RightChild != NULL)
	{
		cout << '(';
		if (Root->LeftChild != NULL)
		{
			GeneralListOut(Root->LeftChild); 
		}
		cout << ',';

		if (Root->RightChild)
		{
			GeneralListOut(Root->RightChild); 
		}
		cout << ')';
	}
}


/*递归前序遍历二叉树*/
void RecursionPreviousSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		VisitData(Root);
		RecursionPreviousSortErgodic(Root->LeftChild);
		RecursionPreviousSortErgodic(Root->RightChild);
	}
}

/*非递归前序遍历二叉树*/
void NonRecursionPreviousSortErgodic(ROOT &Root)
{
	STACK BinaryTreeStack;
	BinaryTreeStack = new Stack;

	StackMakeNull(BinaryTreeStack);

	struct BinaryTree *Node;
	Node = Root;
	while (Node != NULL)
	{
		VisitData(Node);
		if (Node->RightChild != NULL)
		{
			StackPush(Node->RightChild, BinaryTreeStack);
		}
		if (Node->LeftChild != NULL)
		{
			Node = Node->LeftChild; //进左子树
		}
		else
		{
			Node = StackTop(BinaryTreeStack);
			StackPop(BinaryTreeStack);	//做子树空，访问又子树
		}
	}
}

/*递归中序遍历二叉树*/
void RecursionMiddleSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		RecursionMiddleSortErgodic(Root->LeftChild);
		VisitData(Root);
		RecursionMiddleSortErgodic(Root->RightChild);
	}
}

/*非递归中序遍历二叉树*/
void NonRecursionMiddleSortErgodic(ROOT &Root)
{
	STACK BinaryTreeStack;
	BinaryTreeStack = new Stack;
	StackMakeNull(BinaryTreeStack);

	struct BinaryTree *Node;
	Node = Root;

	while ((Node != NULL) || (!StackIsEmpty(BinaryTreeStack)))
	{
		while (Node != NULL)
		{
			StackPush(Node, BinaryTreeStack);
			Node = Node->LeftChild;
		}
		if (!StackIsEmpty(BinaryTreeStack))
		{
			Node = StackTop(BinaryTreeStack);
			StackPop(BinaryTreeStack);

			VisitData(Node);
			Node = Node->RightChild;
		}
	}
}

/*递归后序遍历二叉树*/
void RecursionRearSortErgodic(ROOT &Root)
{
	if (!BinaryTreeIsEmpty(Root))
	{
		RecursionRearSortErgodic(Root->LeftChild);
		RecursionRearSortErgodic(Root->RightChild);
		VisitData(Root);
	}
}

/*非递归后序遍历二叉树*/
void NonRecursionRearSortErgodic(ROOT &Root)
{
	ROOT Node;
	int Target[30];

	ATSTACK BinaryTreeStack;
	BinaryTreeStack = new AssistStack;
	AssistStackMakeNull(BinaryTreeStack);

	Node = Root;
	while (Node != NULL || !AssistStackIsEmpty(BinaryTreeStack))
	{
		while (Node != NULL)
		{
			AssistStackPush(Node, BinaryTreeStack);
			Target[BinaryTreeStack->Top] = -1;
			Node = Node->LeftChild;
		}
		while (!AssistStackIsEmpty(BinaryTreeStack) && Target[BinaryTreeStack->Top] == 1)
		{
			Node = AssistStackTop(BinaryTreeStack);
			AssistStackPop(BinaryTreeStack);
			VisitData(Node);
		}
		if (!AssistStackIsEmpty(BinaryTreeStack))
		{
			Target[BinaryTreeStack->Top] = 1;
			Node = AssistStackTop(BinaryTreeStack);
			Node = Node->RightChild;
		}
		else
		{
			break;
		}
	}
}

//层次遍历二叉树
void LevelSortErgodic(ROOT &Root)
{
	ROOT Node;
	Node = Root;

	QUEUE Q;
	Q = new Queue;
	Q->Front = 0;
	Q->Rear = 0;

	if (Root == NULL)
	{
		return;
	}
	Q->Elements[++Q->Rear] = Root;
	while (Q->Front != Q->Rear)
	{
		Node = Q->Elements[++Q->Front];
		VisitData(Node);
		if (Node->LeftChild != NULL)
		{
			Q->Elements[++Q->Rear] = Node->LeftChild;
		}
		if (Node->RightChild != NULL)
		{
			Q->Elements[++Q->Rear] = Node->RightChild;
		}
	}
}


BinaryTree *Search(ROOT &Root, char search)
{
	STACK BinaryTreeStack;
	BinaryTreeStack = new Stack;

	StackMakeNull(BinaryTreeStack);

	struct BinaryTree *Node;
	Node = Root;
	while (Node->Data != search)
	{
		if (Node->RightChild != NULL)
		{
			StackPush(Node->RightChild, BinaryTreeStack);
		}
		if (Node->LeftChild != NULL)
		{
			Node = Node->LeftChild; //进左子树
		}
		else
		{
			Node = StackTop(BinaryTreeStack);
			StackPop(BinaryTreeStack);	//做子树空，访问又子树
		}
	}
	return Node;
}


BinaryTree* findLowestCommonAncestor(ROOT &Root, BinaryTree *a, BinaryTree *b)
{
	if (Root == NULL)
	{
		return NULL;
	}
	if (Root == a || Root == b)
	{
		return Root;
	}

	BinaryTree *left = findLowestCommonAncestor(Root->LeftChild, a, b);
	BinaryTree *right = findLowestCommonAncestor(Root->RightChild, a, b);

	if (left && right)
	{
		return Root;
	}

	return left ? left : right;
}

/*二叉树的操作函数*/
/*--------------------------------------------*/
bool BinaryTreeIsEmpty(ROOT &Root)
{
	if (Root != NULL)
	{
		return false;
	}
	return true;
}

char VisitData(ROOT &Root)
{
	cout << Root->Data << " ";
	return Root->Data;
}


/*栈的操作函数*/
/*--------------------------------------------*/
//将栈置空
void StackMakeNull(STACK BinaryTreeStack)
{
	BinaryTreeStack = new Stack;
	BinaryTreeStack->Next = NULL;
}

//压栈
void StackPush(BinaryTree *element, STACK BinaryTreeStack)
{
	STACK Node;
	Node = new Stack;
	Node->Data = element;
	Node->Next = BinaryTreeStack->Next;
	BinaryTreeStack->Next = Node;
}

//删除栈顶元素
void StackPop(STACK BinaryTreeStack)
{
	STACK Node;
	if (BinaryTreeStack->Next)
	{
		Node = BinaryTreeStack->Next;
		BinaryTreeStack->Next = Node->Next;
		delete Node;
	}
}

//弹出栈顶元素
BinaryTree *StackTop(STACK BinaryTreeStack)
{
	if (BinaryTreeStack->Next)
	{
		return (BinaryTreeStack->Next->Data);
	}
	else
	{
		return NULL;
	}
}

//判断栈是否为空
bool StackIsEmpty(STACK BinaryTreeStack)
{
	if (BinaryTreeStack->Next)
	{
		return false;
	}
	else
	{
		return true;
	}
}


/*辅助站栈的操作函数*/
/*--------------------------------------------*/
//将辅助栈置空
void AssistStackMakeNull(ATSTACK AssistStack)
{
	AssistStack->Top = -1;
}

//压栈辅助栈
void AssistStackPush(BinaryTree *Element, ATSTACK AssistStack)
{
	AssistStack->NodePointer[++AssistStack->Top] = Element;
}

BinaryTree *AssistStackTop(ATSTACK AssistStack)
{
	return AssistStack->NodePointer[AssistStack->Top];
}

void AssistStackPop(ATSTACK AssistStack)
{
	AssistStack->Top--;
}

bool AssistStackIsEmpty(ATSTACK AssistStack)
{
	if (AssistStack->Top == -1)
	{
		return true;
	}
	return false;
}


/*--用于生成测试二叉树的函数部分*/
/*--------------------------------------------*/
void CreatTestBinaryTree(ROOT &Root)
{
	//char PreviousSort[11] = "ABDHLEKCFG"; //二叉树的前序序列
	//char MiddleSort[11] = "HLDBEKAFCG";   //二叉树的中序序列

	char PreviousSort[16] = "ABDGLEHIMCFJNK"; //二叉树的前序序列
	char MiddleSort[16] = "GLDBAHEMIJNFKC";   //二叉树的中序序列

	int i = 0, j = 0, length;
	length = strlen(PreviousSort);

	PreMidCreatBinaryTree(Root, PreviousSort, i, MiddleSort, j, length);
}

//根据中序和前序表达式利用递归生成二叉树
void PreMidCreatBinaryTree(ROOT &Root, char *Previous, int i, char *Middle, int j, int length)
{
	int k;
	if (length <= 0) //递归终止的条件
	{
		return;
	}
	Root = new BinaryTree;
	Root->LeftChild = NULL;
	Root->RightChild = NULL;

	Root->Data = Previous[i];
	k = SearchPosition(Middle, Previous[i]);
	PreMidCreatBinaryTree(Root->LeftChild, Previous, (i+1), Middle, j, (k-j));
	PreMidCreatBinaryTree(Root->RightChild, Previous, (i +(k-j)+1), Middle, (k+1), (length-1-(k-j)));
}

//查找当前根节点在中序序列中的位置
int SearchPosition(char *MiddleSort, char element)
{
	int i;
	for (i = 0; MiddleSort[i] != '\0'; i++)
	{
		if (element == MiddleSort[i])
		{
			break;
		}
	}
	return i;
}


liuzmx
关注
专栏目录
C语言二叉树的遍历及应用(栈和队列实现二叉树遍历)
飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘飘
11-11 2363
二叉树的遍历及应用(栈和队列实现二叉树遍历) 案例树 代码 #include <stdio.h> #include <malloc.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int Status; //（1）二叉树结点数据结构 typedef struct BiTNode { // 定义树结束结构 char data;
二叉树的遍历及应用.ppt
05-27
该资源为是一份基于C++程序设计语言的数据结构课程的ppt,内容为二叉树的便遍历及其应用。
二叉树的遍历及其应用
guojz049的博客
06-06 789
#include #include using namespace std; typedef int ElemType; typedef struct TreeNode *BinTree; typedef BinTree Position; typedef struct TreeNode //二叉树的表示 { ElemType Data; BinTree Left; Bi
二叉树的遍历与应用
精神小伙的博客
09-23 632
很多与二叉树相关的算法都是二叉树遍历算法的扩展，所以要熟练掌握对二叉树的各种遍历算法，包括前中后序，层序的递归和非递归算法实现 #include<iostream> #include<queue> #include<stack> #define ElemType int #define MaxSize 50 using namespace std; int widths[MaxSize]; typedef struct BiTNode{ ElemType data
【数据结构】二叉树的遍历及应用
热门推荐
不用先生的博客
06-08 2万+
  【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言       在二叉树的应用中，常常要求在树中查找某些结点，或者对树中的结点统一进行某种处理。因此，就提到了二叉树的遍历问题，对于线性结构来说，遍历是一个很容易解决的问题，而二叉树偏偏是一种非线性的结构，因此需要寻找一种规律。        二叉树由三个基本单元组成，分别是根...
【1291】数据结构上机测试4.1:二叉树的遍历与应用1 SDUTOJ
weixin_34015860的博客
08-21 93
 数据结构上机测试4.1:二叉树的遍历与应用1 Time Limit: 1000ms Memory limit: 65536K有疑问？点这里^_^ 题目描述 输入二叉树的先序遍历序列和中序遍历序列，输出该二叉树的后序遍历序列。 输入 第一行输入二叉树的先序遍历序列； 第二行输入二叉树的中序遍历序列。 输出 输出该二叉树的后序...
二叉树的遍历实验报告.pdf
11-11
1. 二叉树遍历的概念与目的： 遍历二叉树是为了访问树中的所有节点，按照特定的顺序执行操作，如查找、插入或删除节点。在二叉树的应用中，遍历常用于解决问题，如查找特定属性的节点，或者对所有节点进行统一处理。...
数据结构课程设计报告-二叉树的遍历.docx
03-07
10. 结果分析：通过结果分析可以了解二叉树的遍历方法和查找功能的实现情况。 11. 心得体会：通过本次课程设计，学生可以学到递归创建和非递归创建二叉树等有关二叉树的基本知识，并提高动手能力和学习数据结构的...
什么是二叉树的遍历以及学习二叉树的遍历的意义
最新发布
05-20
- 实现二叉树遍历通常需要用到递归或栈等高级数据结构。这些技术对于提高编程能力非常有帮助。 - 通过不断练习编写和调试二叉树遍历的代码，可以显著提升个人的编程技能和逻辑思维能力。 #### 四、总结 综上所述...
二叉树各种遍历算法的C++实现
05-19
在实际应用中，二叉树的遍历算法常常被用于解决复杂的问题，如查找、排序、数据压缩等。通过熟练掌握这些基本概念，你可以更好地设计和实现高效的算法。在C++中，利用递归和栈的特性，我们可以轻松地实现这些遍历...
二叉树遍历算法实现(C#2.0)
akpaul6677的博客
09-23 171
二叉树遍历算法实现(C#2.0) Posted on 2006-09-20 17:42 xuanfeng 阅读(828) 评论(8) 编辑收藏 引用 收藏至365Key 本人用C#2.0实现了二叉树的定义，怎么构造一颗已知的二叉树，用几种常规的算法（先序，中序，后序，层次）遍历二叉树。希望能给有需要人带来帮助，也希望能得到大家的指点。有关C#数据结构的书在书店里找...
二叉树遍历及其应用
q793145253的博客
01-10 1606
二叉树的三种遍历算法的递归实现 特别说明：函数形参中的 void(*visit)(BinTreeNode *p) 代表：采用一个visit的指针指向某个函数，该函数的形参为BinTreeNode *p，该函数的实现体中可以对结点进行处理，传参时将外部函数名传入即可 前、中、后的差别仅在于 visit(subTree) 该语句的位置不同 1、前序遍历 template<class T> void PreOrder(BinTreeNode<T> *subTree, void(*visit
二叉树遍历及应用
汉堡怪兽
12-13 657
二叉树遍历  public class BinarayTree { Node&lt;String&gt; root; public BinarayTree(String data){ root=new Node&lt;&gt;(data,null,null); } public void createTree(){ Node&lt...
二叉树及其应用--二叉树遍历
了不起的阿港的博客
06-28 685
给定二叉树的广义表表示，构造二叉树并输出二叉树的四种遍历顺序。输入说明： 输入仅一行，该行仅由‘(’、‘)’、‘,’以及大小写字符构成的二叉树的广义表表示，字符串长度不超过100。 输出说明： 在接下来的四行中依行输出二叉树的四种遍历 输入样列： A(B(D,),C(E,F(,H))) 输出样列： ABDCEFH DBAECFH DBEHFCA ABCDEFTHab#includ
数据结构与算法分析 -- 二叉树的实现，遍历，与应用
Coder
08-11 156
   1.此篇文章，仅作为《数据结构与算法分析》第四章--树     中的二叉树一节的读书笔记，发出来供大家共同学习。    2.在开始之前，极力向大家推荐Google Docs. 并非做广告，而是google的产品，不得不让人喜欢。 本文中的插图就是用google docs中的编辑器画的。 很好用。 大家可以试一试    3.本文使用图片方式记录，结合图片与文字，能更加容易理解。 ...
图及二叉树的遍历及其相关应用
青天白鹭的博客
08-03 454
1.二叉树遍历 2.图的遍历 1.1 图的存储 参考链接：https://blog.csdn.net/dengpei187/article/details/51899550 1）邻接矩阵 typedef struct{ VertexType vexes[MAX]; //顶点表 EdgeType arc[MAX][MAX]; //邻接矩阵 int numVert...
SDUTOJ1291数据结构上机测试4.1:二叉树的遍历与应用1
weixin_30498921的博客
12-11 128
以SDUTOJ1291数据结构上机测试4.1:二叉树的遍历与应用1为例 https://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2711/pid/1291 思路： 递归实现，化解子问题解决。 先序：ABDCEF 中序：BDAECF 第一步：根据先序遍历...
猿创征文 | 详解二叉树之遍历及其应用（动图遍历演示）
forever的博客
09-01 2629
二叉树的遍历和相关应用的介绍和学习到这里就结束啦~目前简单的一些数据结构基本就拿C实现介绍差不多啦，后面就会进入排序的学习哈。但是在这里，希望大家能够将前面的树的基础概念以及之前的线性结构知识进行回顾复习，使整个纯C数据结构学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。。代码不负有心人，98加满，向前冲啊🐬🎉🎉🎉以上代码均可运行，所用编译环境为 vs2019 ,运行时注意加上编译头文件#define _CRT_SECURE_NO_WARNINGS 1。......
二叉树遍历的一些简单应用
chenyu-max
07-18 1653
输出二叉树的叶子结点 思路：在二叉树遍历算法中增加检测其左右结点是否为空 void PreOrderTraversal (BinTree *BT) { if(BT) { if(!BT->Left && !BT->Right) cout << BT->Value << ednl; PreOrderTraversal(BT->Left); PreOrderTraversal(BT->Right); } } 求二叉
二叉树遍历实现与应用
"二叉树遍历的代码实现与应用" 二叉树是一种重要的数据结构，它由结点构成，每个结点最多有两个子结点，通常分为左子结点和右子结点。二叉树遍历是访问二叉树中所有结点的过程，有三种基本的遍历方法：先序遍历、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值