【算法笔记】二叉树基本操作

二叉树存储结构与基本操作

二叉链表：

struct node{
	typename data;	//数据域
	node* lchild;	//指向左子树根结点的指针
	node* rchild;	//指向右子树根结点的指针
};

由于在二叉树建树前根结点不存在，因此地址一般设为NULL：

node* root=NULL;

新建结点（往二叉树中插入结点的时候），可以使用下面的函数：

//生成一个新结点，v为结点权值
node* newNode(int v){
	node* Node=new node;	//申请地址空间
	Node->data=v;
	Node->lchild=Node->rchild=NULL;	//初始状态下没有左右孩子
	return Node;	//返回新建结点的地址
}

二叉树结点的查找、修改

查找操作是在给定数据域的条件下，在二叉树中找到所有数据域为给定数据域的结点，并将它们的数据域修改为给定的数据域。
递归完成查找修改操作。对当前结点的左子树和右子树分别递归，当前结点为空时到达死胡同。

void search(node* root,int x,int newdata){
	if(root==null){
		return;	//空树，死胡同 
	}
	if(root->data==x){
		root->data=newdata;
	}
	search(root->lchild,x,newdata);
	search(root->rchild,x,newdata);
}

二叉树结点的插入

二叉树结点的插入位置就是数据域在二叉树中查找失败的位置。

//insert函数将在二叉树中插入一个数据域为x的新结点
//根节点指针root要使用引用，否则插入不会成功 
void insert(node* &root,int x){
	if(root == null){ 	//空树，查找失败，插入位置 
		root = newNode(x);
		return;
	}
	if(x插在左子树){
		insert(root->lchild,x);
	}else{
		insert(root->rchild,x);
	}
}

【如何判断是否要加引用？】
如果函数中需要新建结点，即对二叉树的结构作出修改，就需要加引用；如果只是修改当前已有结点的内容，或仅仅是遍历树，就不用加引用。

二叉树的创建

比较常用的写法是把需要插入的数据存储在数组中，然后再将它们使用insert函数一个一个插入二叉树中，名最终返回根结点的指针root。更方便的写法是直接在建立二叉树的过程中便输入数据边插入结点。

//二叉树的建立
node* Create(int data[],int n){
	node* root = null;
	for(int i=0;i<n;i++){
		insert(root,data[i]);
	}
	return root;
} 

root=NULL 结点地址为空（结点不存在）
*root=NULL 结点内容为空（结点存在但没有内容）

完全二叉树的存储结构

对完全二叉树中的任何一个结点（设编号为x），其左孩子的编号一定是2x，而右孩子的编号一定是2x+1。可以使用数组来存放所有结点的信息，1号位存放的必须是根结点，这样就可以用数组的下标来表示结点编号，且左孩子和右孩子的编号都可以直接计算得到。
【判断某个结点是否为叶结点的标志：】
该结点（记下标为root）的左子节点的编号（root*2）大于结点总个数n
【判断某个结点是否为空结点的标志：】
该结点下标root大于结点总个数n。

二叉树的遍历

先序遍历

根左右

//先序遍历
void preorder(node* root){
	if(root == null){
		return;	//到达空树，递归边界 
	}
	//访问根结点，输出数据域
	printf("%d\n",root->data);
	preorder(root->lchild);		//访问左子树 
	preorder(root->rchild);		//访问右子树 
} 

中序遍历

左根右

//中序遍历
void inorder(node* root){
	if(root == null){
		return;
	}
	inorder(root->lchild);
	printf("%d\n",root->data);
	inorder(root->rchild);
} 

后序遍历

左右根

//后序遍历
void postorder(node* root){
	if(root==null){
		return;
	}
	postorder(root->lchild);
	postorder(root->rchild);
	printf("%d\n",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\n",now->data);
		if(now->lchild!=null) q.push(now->lchild);
		if(now->rchild!=null) q.push(now->rchild); 
	} 
} 

若需要计算出每个结点所处的层次，就需要在二叉树结点的定义中添加一个记录层次layer的变量：

struct node{
	int data;	//数据域
	int layer;	//层次
	node* lchild;	//指向左子树根结点的指针
	node* rchild;	//指向右子树根结点的指针
};

在根结点入队前就先令根结点的layer为1来表示根结点是第一层，之后在now->lchild和now->rchild入队之前，把它们的层号都记为当前结点now的层号+1，即

void LayerOrder_num(node* root){
	queue<node*> q;
	root->layer=1;	//根结点层号为1
	q.push(root);
	while(!q.empty()){
		node* now=q.front();
		q.pop();
		printf("%d\n",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);
		}
	} 
}

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

代码：

//已知先序序列pre，中序序列in 
//当前先序序列区间为[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++){
		//在中序序列中找到in[k]==pre[L]的结点
		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->rchild=create(preL+numLeft+1,preR,k+1,inR);
	 
	 return root; 
} 

中序序列可以与先序序列、后序序列、层序序列中的任意一个来构造唯一的二叉树，而后三者两两搭配或是三个一起上都无法构建唯一的二叉树。

二叉树的静态实现

使用数组完成二叉树的所有操作
静态二叉链表：结点的左右指针域使用int型代替，用来表示左右子树的根结点在数组中的下标。

struct node{
	typename data;
	int lchild;
	int rchild;
}Node[maxn];	//结点数组

在这样的定义下，结点的动态生成就可以转变为如下的静态指定：

int index=0;
int newNode(int v){
	Node[index].data=v;
	Node[index].lchild=-1;	//以-1或maxn表示空
	Node[index].rchild=-1;
	reutrn index++;
}

二叉树的查找插入创建：

//查找，root为根结点在数组中的下标
void search(int root,int x,int newdata){
	if(root=-1) return;
	if(Node[root].data==x){
		Node[root].data==newdata;
	}
	search(Node[root].lchild,x,newdata);
	search(Node[root].rchild,x,newdata);
} 
//插入，root为根结点在数组中的下标
void insert(int &root,int x){
	if(root==-1){
		root = newNode(x);
		return;
	}
	if(由二叉树的性质x应该插在左子树)){
		insert(Node[root].lchild,x);
	}else{
		insert(Node[root].rchild,x);
	}
} 
//二叉树的建立，函数返回根结点root的下标
int Create(int data[],int n){
	int root=-1;
	for(int i=0;i<n;i++){
		insert(root,data[i]);
	}
	return root;
} 

二叉树的先序中序后序层次遍历

//先序
void preorder(in root){
	if(root==-1) return;
	printf("%d\n",Node[root].data);
	preorder(Node[root].lchild);
	preorder(Node[root].rchild);
}
//中序
void Inorder(int root){
	if(root==-1) return;
	Inorder(Node[root].lchild);
	printf("%d\n",Node[root].data);
	Inorder(Node[root].rchild);
}
//后序
void postorder(int root){
	if(root==-1) return;
	postorder(Node[root].lchild);
	postorder(Node[root].rchild);
	printf("%d\n",Node[root].data);
}

//层序
void layerorder(int root){
	queue<int> q;	//队列存放结点下标
	q.push(root);
	while(!q.empty()){
		int now=q.front();
		q.pop();
		printf("%d ",Node[now].data);
		if(Node[now].lchild!=-1) q.push(Node[now].lchild);
		if(Node[now].rchild!=-1) q.push(Node[now].rchild);
	} 
}

[PAT A1020] Tree Traversals

给出二叉树的后序遍历序列和中序遍历序列，求这棵二叉树的层序遍历序列

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
const int maxn=30;
using namespace std;
struct node{
	int data;
	node* lchild;
	node* rchild;
};
int pre[maxn],in[maxn],post[maxn];		//先序中序后序
int n;		//结点个数

//后序序列区间为[postL,postR],中序序列区间为[inL,inR]
//create返回构造出的二叉树根结点的地址
node* create(int postL,int postR,int inL,int inR){
	if(postL>postR) return NULL;
	node* root=new node;
	root->data=post[postR];		//root中存放根结点值
	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(postL+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(now->lchild!=NULL) q.push(now->lchild);
		if(now->rchild!=NULL) q.push(now->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;
}