数据结构——树（二）【遍历】

二叉树的遍历

  二叉树的遍历一般有四种：先序遍历、中序遍历、后序遍历、层次遍历，其中，前三种使用深度优先搜索（DFS）实现，层次遍历使用广度优先搜索（BFS）实现。但是左子树一定先于右子树遍历，所谓的“先中后”是指根结点root在遍历中的位置。

先序遍历

先序遍历的实现

  先序遍历的遍历顺序为根节点→左子树→右子树。
  递归式：先访问根节点，再递归访问左子树，最后递归访问右子树。
  递归边界：遇到子树为空（到达了死胡同）

void preOrder(node* root){
	if(root == NULL) return;//到达空树，递归边界
	//访问根节点root，例如将其数据域输出
	printf("%d",root->data);
	//访问左子树
	preOrder(root->lchild);
	//访问右子树
	preOrder(root->rchild);
}

先序遍历的性质

  对一棵二叉树的先序遍历序列，序列的第一个一定是根节点。

中序遍历

中序遍历的实现

  中序遍历的遍历顺序是左子树→根节点→右子树。其他思路和先序遍历一样。

void inOrder(node* root){
	if(root == NULL) return;
	//访问左子树
	inOrder(root->lchild);
	//访问根节点
	printf("%d",root->data);
	//访问右子树
	inOrder(root->rchild);
}

中序遍历的性质

  中序遍历总把根节点放在左子树和右子树中间，因此只要知道根节点，就可以通过根节点在中序遍历中的位置区分出左子树和右子树。

后序遍历

后序遍历的实现

  后序遍历的遍历顺序是左子树→右子树→根节点。

void postOrder(node* root){
	if(root == NULL) return;
	//遍历左子树
	postOrder(root->lchild);
	//遍历右子树
	postOrder(root->rchild);
	printf("%d",root->data);
}

后序遍历序列的性质

  序列的最后一个一定是根节点。

  
  
无论是先序遍历还是后序遍历，都必须知道中序遍历序列后才能唯一地确定一棵树。

  

层序遍历

  层序遍历是指按层次的顺序从根结点向下逐层进行遍历，且对同一层的结点为从左到右遍历。因此，层次遍历就相当于是对二叉树从根结点开始的广度优先搜索，其基本思路如下：

1. 将根结点root加入队列q
2. 取出队首元素，访问它
3. 如果该结点有左孩子，将左孩子入队
4. 如果该结点有右孩子，将右孩子入队
5. 返回2，直到队列为空

void layerOrder(node* root){
	queue<node*> q;//注意队列里是存地址
	q.push(root);//将根结点地址入队
	while(!q.empty()){
		node* now = q.front();//取出队首元素
		q.pop();
		printf("%d",now->data);//访问队首元素
		if(now->lchild !=NULL) q.push(now->lchild);//将左孩子入队
		if(now->rchild !=NULL) q.push(now->rchild);//将右孩子入队
	}
}

  很多题目当中要求计算出每个结点所处的层次，这就要求在二叉树结点的定义里添加一个记录层次layer的变量：

struct node{
	int data;//数据域
	node* lchild;//左孩子
	node* rchild;//右指针域
	int layer;//层次
};

  需要在根结点入队前将根结点的layer =1，之后再左右子树入队前，把他们的layer+1：

//层次遍历
void layOrder(node* root){
	queue<node*> q;
	root->layer = 1;
	q.push(root);
	while(!q.empty()){
		node* now = q.front();
		q.pop();
		printf("%d",now->data);
		if(now->lchild !=NULL){
			now->lchild->layer = now->layer+1;
			q.push(now->lchild);
		}
		if(now->rchild !=NULL){
			now->rchild->layer = now->layer+1;
			q.push(now->rchild);
		}
	}
}

给出遍历序列 重建二叉树

  给定一棵二叉树的先序遍历和中序遍历序列，重建这棵二叉树。

//当前先序序列区间为[preL,preR],中序序列区间为[inL,inR],返回根节点地址
node* create(int preL,int preR,int inL,int inR){
	if(preL>preR){
		return NULL;//先序序列长度小于等于0时，直接返回
	}
	node* root = new node;//新建一个新的结点，用来存放当前二叉树的根节点
	root->data = pre[preL];//新结点的值为根节点的值
	int k;
	for(k = inL;k<=inR;k++){
		if(in[k] == pre[preL]) break; //在中序序列中找到根节点
	}
	int numLeft = k-inL;//左子树的个数
	//左子树的先序区间为[preL+1,preL+numLeft],中序区间为[inL,k-1]
	//返回左子树的根节点地址，赋值给root的左子针
	root->lchild = create(preL+1,preL+numLeft,inL,k-1);//递归创建左子树
	//右子树的先序区间为[preL+numLeft+1,preR],中序区间为[k+1,inR]
	//返回右子树的根节点地址，赋值给root的右指针
	root->rchild = create(preL+numLeft+1,preR,k+1,inR);
	
	return root;//返回根结点指针
}

  
  中序序列可以和先序序列或后序序列、层序序列重建唯一的二叉树，但是后三者两两搭配或三者一起都不可以。

例题

  给出一颗二叉树的后序序列和中序序列，求这棵二叉树层序序列。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 50;
struct node{
	int data;
	node* lchild;
	node* rchild;
}; 
int post[maxn],in[maxn];//后序序列，中序序列
int n;//结点个数 

node* create(int postL,int postR,int inL,int inR){
	if(postL>postR) return NULL;
	node* root = new node;
	root->data = post[postR];
	int k;
	for(k = inL;k<=inR;k++){
		if(in[k] == post[postR]){
			break;
		}
	}
	int numLeft = k-inL;//左子树长度
	root->lchild = create(postL,postL+numLeft-1,inL,k+1);
	root->rchild = create(post+numLeft,postR-1,k+1,inR);
	return root;
}

int num = 0;//已输出的结点个数(用来保持输出格式)
void BFS(node* root){//层次遍历 
	queue<node*> q;
	q.push(root);
	while(!q.empty()){
		node* now = q.front();
		q.pop();
		printf("%d",now->data);
		num++;
		if(num < n) printf(" ");
		if(root->lchild != NULL) q.push(root->lchild);
		if(root->rchild != NULL) q.push(root->rchild);
	}
}

int main(){
	scanf("%d",&n); 
	for(int i =0;i<n;i++){
		scanf("%d",&post[i]);
	}
	for(int i =0;i<n;i++){
		scanf("%d",&in[i]);
	}
	node* root = create(0,n-1,0,n-1);//建树
	BFS(root);//层序遍历
	return 0; 
}

 

树的遍历

树的静态写法

  “树”是一般意义上的树，子节点个数不限且子节点没有先后次序之分。
  借鉴二叉树的节点定义，仍然保留数据域，将指针域存放所有子结点的地址（或者开一个数组，存放所有子结点的地址）。

struct node {
	typename data;
	vector<typename> child;//指针域，存放所有子结点的下标
}Node[maxn];//结点数组

  在考试中，一般涉及到树（非二叉树）都是给了结点的编号，且编号一定是0,1，···，N-1或1,2，···，N。在这种情况下，可以直接用编号作为Node数组的下标。

树的先根遍历

  先访问根节点，再去访问所有子树。

void preOrder(int root){
	printf("%d",Node[root].data);//访问当前结点
	for(int i =0;i<Node[root].child.size();i++){
		preOrder(Node[root].child[i]);//递归访问root的所有子结点
	}
}

树的层序遍历

  从树根开始，一层一层地向下遍历。

void layerOrder(int root){
	queue<int> Q;
	Q.push(root);
	while(!Q.empty()){
		int now = Q.front();
		Q.pop();
		for(int i =0;i<Node[now].child.size();i++){
			Q.push(Node[now].child[i]);
		}
	}
}

  同样的，如果对结点的层号进行求解，则在node定义中添加层号：

struct node{
	int data;
	vector<int> child;
	int layer;//层号
}