数据结构-二叉树的遍历

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

1．先（根）序遍历的递归算法定义：

若二叉树非空，则依次执行如下操作：

⑴ 访问根结点；

⑵ 遍历左子树；

⑶ 遍历右子树。

2．中（根）序遍历的递归算法定义：

若二叉树非空，则依次执行如下操作：

⑴遍历左子树；

⑵访问根结点；

⑶遍历右子树。

3．后（根）序遍历得递归算法定义：

若二叉树非空，则依次执行如下操作：

⑴遍历左子树；

⑵遍历右子树；

⑶访问根结点。

本次代码是之前数据结构课程的实验。

代码实现如下：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<vector> 
#define Size 100
using namespace std;
//测试数据：ABC##DE#G##F###
typedef struct  node{
	char data;	//数据域
	struct node *lchild ,  *rchild;  //左右孩子指针
}BinTNode, *BinTree;   //树中结点类型

typedef struct{
	BinTree *base;
	int front;
	int rear;	
}SqQueue;   //队列

void Bulid(BinTree &H);
void PreOrderTraverse(BinTree H);
void InOrderTraverse(BinTree H);
void LatOrderTraverse(BinTree H);
void HeightOrder(SqQueue &Q);
void EnQueue(SqQueue &Q,BinTree b);
bool PointPath(BinTNode *pRoot,char a,vector<char> &v);

void main()
{
	BinTree H;
	SqQueue Q;
	vector<char> v;
	int y=1;
	while(y){
		printf("请选择0-6\n");
        printf("1.建立二叉树存储结构\n");
	    printf("2.求二叉树的先序遍历\n");
	    printf("3.求二叉树的中序遍历\n");
	    printf("4.求二叉树的后序遍历\n");
	    printf("5.求二叉树的层次遍历\n");
	    printf("6.求给定结点的路径\n");
	    printf("0.退出系统\n");
		int x;
		scanf("%d",&x);
		switch(x)
		{
			case 1:
				printf("请输入字符串\n");
		        Bulid(H);
		        break;
	        case 2:
				PreOrderTraverse(H);
				printf("\n");
				break;
	        case 3:
				InOrderTraverse(H);
				printf("\n");
				break;
         	case 4:
				LatOrderTraverse(H);
				printf("\n");
				break;
        	case 5:
				Q.base=new BinTree[Size];
				Q.front=0;
				Q.rear=0;
				Q.base[Q.rear]=H;
				Q.rear++;
				HeightOrder(Q);
				break;
	        case 6:
			    char a;
				printf("请输入你要查找的结点值\n");
				scanf("%s",&a);
				PointPath(H,a,v);
				if(v.size()==0)
					printf("未找到该结点值\n");
				v.clear();
				break;
	        case 0:
				exit(0);
				break;
		}
	}
}

void Bulid(BinTree &H)
{
	char ch;
    cin>>ch;
	if(ch!='#')
	{
		H=new node;
		H->data=ch;
		Bulid(H->lchild);
		Bulid(H->rchild);
	}
	else{
		H=NULL;
	}
}

void PreOrderTraverse(BinTree H)
{
	if(H){
		cout<<H->data;
		PreOrderTraverse(H->lchild);
		PreOrderTraverse(H->rchild);;
	}
}

void InOrderTraverse(BinTree H)
{
	if(H){	
		InOrderTraverse(H->lchild);
		cout<<H->data;
		InOrderTraverse(H->rchild);
	}
}

void LatOrderTraverse(BinTree H){
	if(H){		
		LatOrderTraverse(H->lchild);		
		LatOrderTraverse(H->rchild);
		cout<<H->data;
	}
}

void EnQueue(SqQueue &Q,BinTree b){
	if((Q.rear+1)%Size==Q.front)
		return ;
	Q.base[Q.rear]=b;
	Q.rear=(Q.rear+1)%Size;
}

void HeightOrder(SqQueue &Q){
	while(Q.front<Q.rear){
		cout<<Q.base[Q.front]->data;
		if(Q.base[Q.front]->lchild!=NULL)
			EnQueue(Q,Q.base[Q.front]->lchild); 			
		if(Q.base[Q.front]->rchild!=NULL)	
			EnQueue(Q,Q.base[Q.front]->rchild);			
		Q.front=(Q.front+1)%Size;		
	}
	printf("\n");
}
	
bool PointPath(BinTNode *pRoot,char a,vector<char> &v)
{
	if(pRoot==NULL)
	{
		return false;
	}
	v.push_back(pRoot->data);
	bool found=false;
	if(pRoot->data==a)
	{
		for(int i=0;i<v.size();i++){
			cout<<v[i];
			if(i!=v.size()-1)
				cout<<"-->";
		}
		cout<<endl;
		return true;
	}
	if(!found && pRoot->lchild)
	{
		found=PointPath(pRoot->lchild,a,v);
	}
	if(!found && pRoot->rchild)
	{
		found=PointPath(pRoot->rchild,a,v);
	}
	if(!found)
		found=PointPath(pRoot->lchild,a,v);
	return found;
}