二叉树的遍历的应用

最新推荐文章于 2022-11-09 21:33:34 发布
最新推荐文章于 2022-11-09 21:33:34 发布
阅读量425 收藏 3
点赞数
分类专栏： 数据结构 剑指百度 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39804483/article/details/86601665
版权
数据结构 同时被 3 个专栏收录
18 篇文章 1 订阅
订阅专栏
剑指百度
17 篇文章 0 订阅
订阅专栏
算法
14 篇文章 0 订阅
订阅专栏

 

//二叉树的定义
typedef struct  _BinaryTreeNode
{
	char data;
	//int ltag , rtag;
	struct _BinaryTreeNode *lchild;
	struct _BinaryTreeNode *rchild; 

}BTNode;
/*
1、表达式(a-(b+c)*(d/e))存储在存储在以二叉链表为存储结构的二叉树中，编写程序求出表达式中的值。
*/
int op(int A,int B ,char oper)
{
	switch (oper)
	{
	case '+':
		return A+B;
		break;
	case '-':
		return A-B;
		break;
	case '*':
		return A*B;
		break;
	case '/':
		return A/B;
		break;
	}


}
int comp(BTNode *p)
{
	int A,B;
	if (p!=NULL)
	{
		if (p->lchild!=NULL&&p->rchild!=NULL)
		{
			A = comp(p->lchild);
			B = comp(p->rchild);
			return op(A,B,p->data);
		}
		else
			return p->data -'0';
	}
	else
		return 0;
}

 

//写出一个算法求出二叉树的高度
int  getDepth(BTNode *p)
{
	int LD=0,RD=0;
	if (p ==NULL)
	{
		return 0;
	}
	else
	{
		LD = getDepth(p->lchild);
		RD = getDepth(p->rchild);
		return (LD>RD ? LD:RD)+1;
	}

}

 

 

//在以二叉链表为存储结构的链表中查询data域值等于key的节点。
//前序遍历就OK  可以用中序遍历么 
void Search_one(BTNode *p, BTNode *&q, char key)
{
	if (p!=NULL)
	{
		if (p->data==key)
		{
			q = p;
		}
		else
		{

			Search_one(p->lchild,q,key);
			Search_one(p->rchild,q,key);
		}
	}

}
//前序遍历就OK  可以用中序遍历么 
void Search_two(BTNode *p, BTNode *&q, char key)
{
	if (p!=NULL)
	{
		if (p->data==key)
		{
			q = p;
		}
		else
		{

			Search_two(p->lchild,q,key);
			if (q==NULL)
			{
				Search_two(p->rchild,q,key);
			}//只有在左子树中没有找到才在右子树中找
		}
	}

}

 

//求出二叉树的最大宽度：某一层节点个数最多的那一层
int BinaryTreeWidth(BTNode *root)
{
	//核心思想： 第一次入队根节点，这个时候的宽度为1 当根节点出队，其子节点入队之后，这个队列的大小就是这一层的宽度 以此类推。
	if (root ==NULL)
	{
		return 0;
	}
	int  width = 0;
	int  maxwidth =0;
	queue<BTNode*> q;
	BTNode *p = NULL;
	q.push(root);
	while(!q.empty())
	{
		width = q.size();//本层元素的个数
		if (maxwidth<width)
		{
			maxwidth = width;
		}
		//将该层元素的孩子入栈
		for (int i = 0;i<width;i++)
		{
			p = q.front();
			q.pop();
			if (p->lchild!=NULL)
			{
				q.push(p->lchild);
			}
			if (p->lchild!=NULL)
			{
				q.push(p->rchild);
			}
		}

	}
	return maxwidth;
//求二叉树的深度的非递归算法
/*
其实知道了树的深度的非递归算法，很容易知道树的深度 因为树的宽度的外层循环每进行一次，树的深度就增加1
*/
int BinaryTreeDepth(BTNode *root)
{
	//核心思想： 第一次入队根节点，这个时候的宽度为1 当根节点出队，其子节点入队之后，这个队列的大小就是这一层的宽度 以此类推。
	if (root ==NULL)
	{
		return 0;
	}
	int  width = 0 ;
	int  dept = 0 ;
	queue<BTNode*> q;
	BTNode *p = NULL;
	q.push(root);
	
	while(!q.empty())
	{
		width = q.size();//本层元素的个数
		dept++;
		//将该层元素的孩子入栈
		for (int i = 0;i<width;i++)
		{
			p = q.front();
			q.pop();
			if (p->lchild!=NULL)
			{
				q.push(p->lchild);
			}
			if (p->lchild!=NULL)
			{
				q.push(p->rchild);
			}
		}

	}
	return dept;
}

 

//中序和后续确定一颗树 --后续确定根的位置，中序把树分为两个部分
BTNode *BTConstruct23(char *inorder,char *postorder,int inStart,int inEnd,int postStart,int postEnd)
{
	//建立新的节点
	BTNode *tree = new BTNode;
	tree->data =postorder[postEnd];//后序遍历的最后一个节点一定是根节点
	tree->lchild =NULL;//前序遍历的第一个节点将中序遍历的节点分为左右子树
	tree->rchild =NULL;

	if (inStart==inEnd&&postStart==postEnd)
	{
		return tree;
	}
	int root =0;
	//在中序遍历中查找该值
	for ( root = inStart;root<inEnd;root++)
	{
		if (inorder[root]==postorder[postEnd])
			break;
	}
	//划分左子树
	int leftTreeLength = root - inStart;
	//cout<<leftTreeLength<<endl;
	int rightTreeLength = inEnd - root;
	//cout<<rightTreeLength<<endl;
	
	if (leftTreeLength>0)
	{
		//注意中序和后续保持元素个数相等即为正确的 leftTreeLength-1
		tree->lchild = BTConstruct23(inorder,postorder,inStart,root-1,postStart,postStart+leftTreeLength-1);
		
	}
	if (rightTreeLength>0)
	{
		tree->rchild = BTConstruct23(inorder,postorder,root+1,inEnd,postStart+leftTreeLength,postEnd-1);
	}
	return tree;
}
BTNode *BTConstruct12(char *preorder,char *inorder,int preStart,int preEnd,int inStart,int inEnd)
{
	//建立新的节点
	BTNode *tree = new BTNode;
	tree->data =preorder[preStart];//前序遍历的第一个节点一定是根节点
	tree->lchild =NULL;//前序遍历的第一个节点将中序遍历的节点分为左右子树
	tree->rchild =NULL;

	if (preStart==preEnd&&inStart==inEnd)
	{
		return tree;
	}
	int root =0;
	//在中序遍历中查找该值
	for ( root = inStart;root<=inEnd;root++)
	{
		if (inorder[root]==preorder[preStart])
			break;
	}
	//划分左子树
	int leftTreeLength = root - inStart;
	int rightTreeLength = inEnd - root;
	if (leftTreeLength>0)
	{
		tree->lchild = BTConstruct12(preorder,inorder,preStart+1,preStart+leftTreeLength,inStart,root-1);
	}
	if (rightTreeLength>0)
	{
		tree->rchild = BTConstruct12(preorder,inorder,preStart+1+leftTreeLength,preEnd,root+1,inEnd);
	}
	return tree;
}
//根据二叉树的前序和中序遍历确定一颗二叉树
BTNode * RecoveryBinaryTreeBy12(char* preorder ,int lenpre,char *inorder,int lenin)
{
	if (lenpre==0&& lenin==0)
	{
		return NULL;
	}
	return BTConstruct12(preorder,inorder,0,lenpre-1,0,lenin-1);
}


//去取出先序遍历的第k的点
int n =0;
void pretrave(BTNode*p ,int key)
{
	if (p!=NULL)
	{
		n++;
		if (key==n)
		{
			cout<<p->data<<endl;
			return;
		}
		pretrave(p->lchild,key);
		pretrave(p->rchild,key);
	}
	//cout<<"不存在"<<endl;
}

#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>
#include<map>
#include<stack>
#include <queue>
#define MAX_Size 100;
using namespace std;
//
//  BinaryTreeNode.h
//  BinaryTreeNode
//
//  Created by 吴珝君 on 2018/12/25.
//  Copyright  ©   2018年 闲着也是贤者. All rights reserved.
//

typedef struct  _BinaryTreeNode
{
	char data;
	//int ltag , rtag;
	struct _BinaryTreeNode *lchild;
	struct _BinaryTreeNode *rchild; 

}BTNode;

/*
1、表达式(a-(b+c)*(d/e))存储在存储在以二叉链表为存储结构的二叉树中，编写程序求出表达式中的值。
*/
int op(int A,int B ,char oper)
{
	switch (oper)
	{
	case '+':
		return A+B;
		break;
	case '-':
		return A-B;
		break;
	case '*':
		return A*B;
		break;
	case '/':
		return A/B;
		break;
	}


}
int comp(BTNode *p)
{
	int A,B;
	if (p!=NULL)
	{
		if (p->lchild!=NULL&&p->rchild!=NULL)
		{
			A = comp(p->lchild);
			B = comp(p->rchild);
			return op(A,B,p->data);
		}
		else
			return p->data -'0';
	}
	else
		return 0;
}
//写出一个算法求出二叉树的高度
int  getDepth(BTNode *p)
{
	int LD=0,RD=0;
	if (p ==NULL)
	{
		return 0;
	}
	else
	{
		LD = getDepth(p->lchild);
		RD = getDepth(p->rchild);
		return (LD>RD ? LD:RD)+1;
	}

}
//在以二叉链表为存储结构的链表中查询data域值等于key的节点。
//前序遍历就OK  可以用中序遍历么 
void Search_one(BTNode *p, BTNode *&q, char key)
{
	if (p!=NULL)
	{
		if (p->data==key)
		{
			q = p;
		}
		else
		{

			Search_one(p->lchild,q,key);
			Search_one(p->rchild,q,key);
		}
	}

}
//前序遍历就OK  可以用中序遍历么 
void Search_two(BTNode *p, BTNode *&q, char key)
{
	if (p!=NULL)
	{
		if (p->data==key)
		{
			q = p;
		}
		else
		{

			Search_two(p->lchild,q,key);
			if (q==NULL)
			{
				Search_two(p->rchild,q,key);
			}//只有在左子树中没有找到才在右子树中找
		}
	}

}
//求出二叉树的最大宽度：某一层节点个数最多的那一层
int BinaryTreeWidth(BTNode *root)
{
	//核心思想： 第一次入队根节点，这个时候的宽度为1 当根节点出队，其子节点入队之后，这个队列的大小就是这一层的宽度 以此类推。
	if (root ==NULL)
	{
		return 0;
	}
	int  width = 0;
	int  maxwidth =0;
	queue<BTNode*> q;
	BTNode *p = NULL;
	q.push(root);
	while(!q.empty())
	{
		width = q.size();//本层元素的个数
		if (maxwidth<width)
		{
			maxwidth = width;
		}
		//将该层元素的孩子入栈
		for (int i = 0;i<width;i++)
		{
			p = q.front();
			q.pop();
			if (p->lchild!=NULL)
			{
				q.push(p->lchild);
			}
			if (p->lchild!=NULL)
			{
				q.push(p->rchild);
			}
		}

	}
	return maxwidth;
}
//求二叉树的深度的非递归算法
/*
其实知道了树的深度的非递归算法，很容易知道树的深度 因为树的宽度的外层循环每进行一次，树的深度就增加1
*/
int BinaryTreeDepth(BTNode *root)
{
	//核心思想： 第一次入队根节点，这个时候的宽度为1 当根节点出队，其子节点入队之后，这个队列的大小就是这一层的宽度 以此类推。
	if (root ==NULL)
	{
		return 0;
	}
	int  width = 0 ;
	int  dept = 0 ;
	queue<BTNode*> q;
	BTNode *p = NULL;
	q.push(root);
	
	while(!q.empty())
	{
		width = q.size();//本层元素的个数
		dept++;
		//将该层元素的孩子入栈
		for (int i = 0;i<width;i++)
		{
			p = q.front();
			q.pop();
			if (p->lchild!=NULL)
			{
				q.push(p->lchild);
			}
			if (p->lchild!=NULL)
			{
				q.push(p->rchild);
			}
		}

	}
	return dept;
}
int m =0;

//中序和后续确定一颗树 --后续确定根的位置，中序把树分为两个部分
BTNode *BTConstruct23(char *inorder,char *postorder,int inStart,int inEnd,int postStart,int postEnd)
{
	//建立新的节点
	BTNode *tree = new BTNode;
	tree->data =postorder[postEnd];//后序遍历的最后一个节点一定是根节点
	tree->lchild =NULL;//前序遍历的第一个节点将中序遍历的节点分为左右子树
	tree->rchild =NULL;

	if (inStart==inEnd&&postStart==postEnd)
	{
		return tree;
	}
	int root =0;
	//在中序遍历中查找该值
	for ( root = inStart;root<inEnd;root++)
	{
		if (inorder[root]==postorder[postEnd])
			break;
	}
	//划分左子树
	int leftTreeLength = root - inStart;
	//cout<<leftTreeLength<<endl;
	int rightTreeLength = inEnd - root;
	//cout<<rightTreeLength<<endl;
	
	if (leftTreeLength>0)
	{
		//注意中序和后续保持元素个数相等即为正确的 leftTreeLength-1
		tree->lchild = BTConstruct23(inorder,postorder,inStart,root-1,postStart,postStart+leftTreeLength-1);
		
	}
	if (rightTreeLength>0)
	{
		tree->rchild = BTConstruct23(inorder,postorder,root+1,inEnd,postStart+leftTreeLength,postEnd-1);
	}
	return tree;
}
//根据二叉树的前序和中序遍历确定一颗二叉树
BTNode * RecoveryBinaryTreeBy23(char* inorder ,int lenin,char *postorder,int lenpost)
{
	if (lenin==0&& lenpost==0)
	{
		return NULL;
	}
	return BTConstruct23(inorder,postorder,0,lenin-1,0,lenpost-1);
}
void PostOrder(BTNode *root)
{
	if (root ==NULL)
	{
		return ;
	}
	PostOrder(root->lchild);
	PostOrder(root->rchild);
	cout<<root->data<<endl;
}

BTNode *BTConstruct12(char *preorder,char *inorder,int preStart,int preEnd,int inStart,int inEnd)
{
	//建立新的节点
	BTNode *tree = new BTNode;
	tree->data =preorder[preStart];//前序遍历的第一个节点一定是根节点
	tree->lchild =NULL;//前序遍历的第一个节点将中序遍历的节点分为左右子树
	tree->rchild =NULL;

	if (preStart==preEnd&&inStart==inEnd)
	{
		return tree;
	}
	int root =0;
	//在中序遍历中查找该值
	for ( root = inStart;root<=inEnd;root++)
	{
		if (inorder[root]==preorder[preStart])
			break;
	}
	//划分左子树
	int leftTreeLength = root - inStart;
	int rightTreeLength = inEnd - root;
	if (leftTreeLength>0)
	{
		tree->lchild = BTConstruct12(preorder,inorder,preStart+1,preStart+leftTreeLength,inStart,root-1);
	}
	if (rightTreeLength>0)
	{
		tree->rchild = BTConstruct12(preorder,inorder,preStart+1+leftTreeLength,preEnd,root+1,inEnd);
	}
	return tree;
}
//根据二叉树的前序和中序遍历确定一颗二叉树
BTNode * RecoveryBinaryTreeBy12(char* preorder ,int lenpre,char *inorder,int lenin)
{
	if (lenpre==0&& lenin==0)
	{
		return NULL;
	}
	return BTConstruct12(preorder,inorder,0,lenpre-1,0,lenin-1);
}

//去取出先序遍历的第k的点
int n =0;
void pretrave(BTNode*p ,int key)
{
	if (p!=NULL)
	{
		n++;
		if (key==n)
		{
			cout<<p->data<<endl;
			return;
		}
		pretrave(p->lchild,key);
		pretrave(p->rchild,key);
	}
	//cout<<"不存在"<<endl;
}

int main()
{
	/*
	测试程序
	*/

	//is2operator(v,vv,ms);
	BTNode b1,b2,b3,b4,b5,b6,b7,b8,b9;
	b1.data ='*';

	b2.data ='-';

	b3.data ='/';
	b3.lchild =NULL;
	b3.rchild =NULL;

	b4.data ='a';
	b4.lchild =NULL;
	b4.rchild =NULL;
	b5.data ='+';
	b5.lchild =NULL;
	b5.rchild =NULL;
	b5.data ='+';
	b5.lchild =NULL;
	b5.rchild =NULL;
	b6.data ='d';
	b6.lchild =NULL;
	b6.rchild =NULL;
	b7.data ='e';
	b7.lchild =NULL;
	b7.rchild =NULL;
	b8.data ='b';
	b8.lchild =NULL;
	b8.rchild =NULL;

	b9.data ='c';
	b9.lchild =NULL;
	b9.rchild =NULL;

	b1.lchild = &b2;
	b1.rchild =&b3;

	b2.lchild =&b4;
	b2.rchild =&b5;
	b3.lchild =&b6;
	b3.rchild = &b7;
	b5.lchild = &b8;
	b5.rchild =&b9;
	char preorder[9] ={'*','-','a','+','b','c','/','d','e'};
	char inorder[9] ={'a','-','b','+','c','*','d','/','e'};
	char postorder[9] ={'a','b','c','+','-','d','e','/','*'};
	//BTNode * r1= RecoveryBinaryTreeBy12(preorder,9,inorder,9);
	//PostOrder(r1);
	BTNode * r2= RecoveryBinaryTreeBy23(inorder,9,postorder,9);
	PostOrder(r2);
	system("pause");
}

 

吴珝君
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历算法的应用
04-11
课程设计文档 利用二叉树遍历算法的框架和思路，假设访问结点的具体操作不仅仅局限于输出结点数据域的值，而把访问延伸到对结点的判别、计数等其他操作。这样可以解决一些关于二叉树的其他实际问题。（1） 统计二叉树中结点总数m，叶子结点个数n0 (2) 求二叉树的树深
二叉树遍历问题二叉树遍历问题
最新发布
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树遍历有四种常见的方法：先序遍历、中序...
二叉树的遍历与应用
精神小伙的博客
09-23 629
很多与二叉树相关的算法都是二叉树遍历算法的扩展，所以要熟练掌握对二叉树的各种遍历算法，包括前中后序，层序的递归和非递归算法实现 #include<iostream> #include<queue> #include<stack> #define ElemType int #define MaxSize 50 using namespace std; int widths[MaxSize]; typedef struct BiTNode{ ElemType data
二叉树遍历及其应用
q793145253的博客
01-10 1586
二叉树的三种遍历算法的递归实现 特别说明：函数形参中的 void(*visit)(BinTreeNode *p) 代表：采用一个visit的指针指向某个函数，该函数的形参为BinTreeNode *p，该函数的实现体中可以对结点进行处理，传参时将外部函数名传入即可 前、中、后的差别仅在于 visit(subTree) 该语句的位置不同 1、前序遍历 template<class T> void PreOrder(BinTreeNode<T> *subTree, void(*visit
二叉树的遍历及其应用
guojz049的博客
06-06 786
#include #include using namespace std; typedef int ElemType; typedef struct TreeNode *BinTree; typedef BinTree Position; typedef struct TreeNode //二叉树的表示 { ElemType Data; BinTree Left; Bi
树（三）——二叉树遍历的应用
在校生
11-09 1660
二叉树遍历的应用（求二叉树结点数、叶子结点数、输出叶子结点、二叉树高度、建立二叉链表存储的二叉树、二叉树相似性的判定、求结点的双亲）
易语言二叉树遍历
07-21
- 二叉树遍历在许多实际问题中都有应用，如文件系统、数据库索引、编译器的符号表管理等。在易语言中，你可以创建一个简单的二叉树来模拟这些场景，并使用提供的源码作为参考。 综上所述，易语言二叉树遍历涉及到...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历是计算机科学中的一个重要概念，主要应用于数据结构和算法领域。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是指按照特定顺序访问二叉树的所有...
二叉树遍历，c语言 实现数据结构二叉树遍历
04-19
二叉树遍历是计算机科学中数据结构领域的重要概念，主要应用于树形数据结构的处理。在C语言中实现二叉树遍历涉及到对指针的熟练操作和递归理解。下面将详细介绍二叉树的三种基本遍历方法：前序遍历、中序遍历和后序...
二叉树的遍历及应用.ppt
05-27
该资源为是一份基于C++程序设计语言的数据结构课程的ppt,内容为二叉树的便遍历及其应用。
二叉树遍历的应用
0start1的博客
10-26 825
二叉树遍历相关重要题目
二叉树的应用—二叉树遍历的应用
num24的专栏
11-07 716
在以上讨论的遍历算法中，访问结点的数据域信息，即操作Visite（bt->data）具有更一般的意义，需根据具体问题，对bt 数据进行不同的操作。下面介绍几个遍历操作的典型应用。 1．查找数据元素 Search（bt，x）在bt 为二叉树的根结点指针的二叉树中查找数据元素x。查找成功时返回该结点的指针；查找失败时返回空指针。 算法实现如下，注意遍历算法中的Visite(bt->dat
【数据结构】二叉树的遍历及应用
热门推荐
不用先生的博客
06-08 2万+
  【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言       在二叉树的应用中，常常要求在树中查找某些结点，或者对树中的结点统一进行某种处理。因此，就提到了二叉树的遍历问题，对于线性结构来说，遍历是一个很容易解决的问题，而二叉树偏偏是一种非线性的结构，因此需要寻找一种规律。        二叉树由三个基本单元组成，分别是根...
二叉树的遍历及应用
XIEANQAQ的博客
12-08 287
#include #include #include #define MAX 100 int count=0; typedef struct tree { char ch; struct tree *Lchild,*Rchild; }*TREE; typedef struct Seqstack { TREE p[MAX]; int top;
二叉树遍历及应用
汉堡怪兽
12-13 655
二叉树遍历  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 681
给定二叉树的广义表表示，构造二叉树并输出二叉树的四种遍历顺序。输入说明： 输入仅一行，该行仅由‘(’、‘)’、‘,’以及大小写字符构成的二叉树的广义表表示，字符串长度不超过100。 输出说明： 在接下来的四行中依行输出二叉树的四种遍历 输入样列： A(B(D,),C(E,F(,H))) 输出样列： ABDCEFH DBAECFH DBEHFCA ABCDEFTHab#includ
二叉树的遍历应用
megamirurutia的专栏
03-20 634
二叉树的遍历应用   #include #include #include #define MAXSIZE 100  typedef struct TreeNode {    char data;     TreeNode *lchild,*rchild; }TreeNode; void CreateBiTree(TreeNode *&,char []);    /
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值