线索二叉树的实现_C

线索二叉树的背景

在聊线索二叉树之前，先来看看单向链表：

单向链表的每一个结点都有指向下一个结点的指针域，却没有指向上一个结点的指针，给使用带来不方便，为此双向链表应运而生 。

在二叉树中想知道某个结点的前驱结点是谁的时候，就得重新遍历一遍， 浪费时间。
所以，有人创建了一棵树，在进行第一遍某种遍历方式的时候，就”顺便“ 记录一下某些结点的前驱结点和后继结点 。

我们知道二叉树有4种遍历， 前/中/后序遍历和层序遍历， 前中后遍历的是以先访问根节点，还是中间访问，还是最后访问来作区别。

而在每棵树都有叶结点，在中序遍历中如果刚好利用上这些叶结点标记一下，就可以减少空间浪费 ，也可以快速访问到某些结点。

【补充说明】
个人认为对于初学者来说，最容易漏掉的是头结点的处理， 因为

#if 0
程序目的，建立 一棵二叉搜索树，并初始化， 用三种遍历方法遍历一遍
然后再实现这棵树的线索化 
@建树
@树的初始化（写一个根节点）
@左子树比右子树的要小
#endif 

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#define Maxsize 8 
typedef int element;
typedef struct BinTree
{
	struct BinTree* left;    
	struct BinTree* right;  
	element data;  
	int ltag;    
	int rtag;   //在遍历时标记
}BT;
BT  bt ,*b;
BT* pre = NULL;   //始终指向刚刚访问过的结点
void InorderThreading(BT* p, BT* Node);
BT* BuildTree(BT* Node, int a[]);
BT* InitNode(BT* New, element x);
BT* InsertNode(BT* Node, element x);
void midprintTree(BT* Node);
void midTree(BT* Node);
void preTree(BT* Node);
void FrontTree(BT* Node);
int main()
{
	int Tree[Maxsize] = {4,3,2,6,10,5,4,11};
	b = InitNode(b, Tree[0]);
	b=BuildTree(b, Tree);
	preTree(b);
	printf("\n");
	midprintTree(b);
	printf("\n");
	InorderThreading(&bt,b);
}
//树或称为根结点的初始化： 初始化根节点 ，返回根节点 
BT *InitNode(BT* Node, element x)
{
	Node = (BT*)malloc(sizeof(BT));
	Node->data = x;
	Node->right = Node->left = NULL;
	Node->ltag = Node->rtag = 0;
	return Node;
}
//建树：入口参数： 树的根节点
//将所有数据挂到树上，利用的是插入算法
BT* BuildTree(BT* Node, int a[])
{
	int i = 1, x = 0;
	for (; i < Maxsize; i++)
	{
		x = a[i];
		Node = InsertNode(Node, x);
	}
	return Node;
}
//插入结点
//入口参数：这棵树的根节点
//返回值： 插好元素的树的根节点
BT* InsertNode(BT* Node, element x)
{
	if (Node == NULL)
	{
		Node = InitNode(Node, x);
	}
	else
	{
		if(Node->data > x)
	    {
		 Node->left = InsertNode(Node->left, x);
	    }
	    else
	    {
	    Node->right = InsertNode(Node->right, x);
	    }
	}
	return Node;
	
}
//==================建树完成==========================
void preTree(BT* Node)
{
	if (Node == NULL)
		return;
	printf("%3d", Node->data);
	preTree(Node->left);	
	preTree(Node->right);
}
//在中序遍历中修改好指针，就是最后一棵子树的左右指针指向他们前驱后继指针 
void midTree(BT* Node)
{
	if (Node == NULL)
	{
		return;
	}
	midTree(Node->left);
	//  如果该结点没有左孩子，设置ltag为前驱线索 
	if (Node->left == NULL) 
	{
		Node->ltag = 1;
		Node->left = pre;
	}
//当走到当前结点的下一个结点的时候，就可以将当前结点添加下一个结点作为后继结点（妙啊）
	if (pre->right == NULL)
	{
		pre->rtag = 1;
		pre->right = Node;
	}
	pre = Node;//在程序最开始，要设置一个头结点，否则前驱结点就是空指针，会引起内存保护，程序异常
	midTree(Node->right);
}
//开辟一个头结点 给pre一个空间 ，防止内存保护
void InorderThreading(BT* p ,BT * Node )
{
	p = (BT*)malloc(sizeof(BT));
	p->ltag = 0;
	p->rtag = 1;
	p->right = p; //先指自己  //右边作为线索 ，让左右最后一个指向它 
	if (Node == NULL)//空树
	{
		p->left = p;
	}
	else
	{
		p->left = Node; //指向根节点
		pre = p;         //给定义好的全局变量头结点
		midTree(Node); 
		pre->right = p;
		pre->rtag = 1;
		p->right = pre; 
	}
}
void FrontTree(BT* Node)
{
	if (Node == NULL)
		return;
	FrontTree(Node->left);
	FrontTree(Node->right);
	printf("%3d", Node->data);
}
void midprintTree(BT* Node)
{
	if (Node == NULL)
		return;
	midprintTree(Node->left);
	printf("%3d", Node->data);
	midprintTree(Node->right);
	
}