树和二叉树_2

---

一、二叉树遍历方式

三种遍历方式：

1. 前序遍历：根->左->右
2. 中序遍历：左->根->右
3. 后序遍历：左->右->根

根据遍历方式可以实现二叉树的序列化。就是通过中序加另一个序还原二叉树。

---

二、二叉树线索化

1. 左边空指针指向节点的前驱节点
2. 右边空指针指向节点的后继节点

线索化的目的是为了二叉树通过访问链表形式进行遍历，即不需要递归。

---

三、代码实现

//二叉树遍历和线索化

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
#include <time.h>
using namespace std;

typedef struct Node{
	int key,ltag,rtag;//1是线索 0是边 
	struct Node *lchild,*rchild;
} Node;
Node *getNewNode(int key){
	Node *p=(Node *)malloc(sizeof(Node));
	p->key=key;
	p->ltag=0;
	p->rtag=0;
	p->lchild=p->rchild=NULL;
	return p;
}
void clear(Node *root){
	if(root==NULL) return ;
	if(root->ltag==0) clear(root->lchild);
	if(root->rtag==0) clear(root->rchild);
	free(root);
	return ;
}
Node *insert(Node *root,int key){
	if(root==NULL) return getNewNode(key);
	if(rand()%2) root->lchild=insert(root->lchild,key);
	else root->rchild=insert(root->rchild,key);
	return root;
}

void pre_order(Node *root){
	if(root==NULL) return ;
	printf("%d ",root->key);
	if(root->ltag==0) pre_order(root->lchild);
	if(root->rtag==0) pre_order(root->rchild);
	return ;
}
void in_order(Node *root){
	if(root==NULL) return ;
	if(root->ltag==0) in_order(root->lchild);
	printf("%d ",root->key);
	if(root->rtag==0) in_order(root->rchild);
	return ;
}
void post_order(Node *root){
	if(root==NULL) return ;
	if(root->ltag==0) post_order(root->lchild);
	if(root->rtag==0) post_order(root->rchild);
	printf("%d ",root->key);
	return ;
}
Node *pre_node=NULL,*inorder_root=NULL;
void __build_inorder_thread(Node *root){
	//按照中序遍历将二叉树线索化
	//出现了一个bug：最后一个节点无法进行线索化,因此需要进行一次封装 
	if(root==NULL) return ;
	if(root->ltag==0) __build_inorder_thread(root->lchild);
	if(inorder_root==NULL) inorder_root=root;
	if(root->lchild==NULL){
		root->lchild=pre_node;
		root->ltag=1;
	}
	if(pre_node&&pre_node->rchild==NULL){
		pre_node->rchild=root;
		pre_node->rtag=1;
	}
	pre_node=root;
	if(root->rtag==0) __build_inorder_thread(root->rchild);
	return ;
}
void build_inorder_thread(Node *root){
	__build_inorder_thread(root);
	pre_node->rchild=NULL;
	pre_node->rtag=1;
	return ;
}
Node *getNext(Node *root){
	if(root->rtag==1) return root->rchild;
	//找到右子树最左边的节点
	root=root->rchild;
	while(root->ltag==0&&root->lchild) root=root->lchild;
	return root;
}

int main(){
	srand(time(0));
	Node *root=NULL;
	#define MAX_NODE 10
	for(int i=0;i<MAX_NODE;i++){
		root=insert(root,rand()%100);
	}
	pre_node=NULL;
	inorder_root=NULL;
	build_inorder_thread(root);
	pre_order(root);
	printf("\n");
	in_order(root);
	printf("\n");
	post_order(root);
	printf("\n");

	//有了中序的线索化之后可以像访问链表一样操作
	Node *node=inorder_root;
	while(node){
		printf("%d ",node->key);
		node=getNext(node);
	}
	
	clear(root);
	return 0;
}