void InThreading(BiThrTree p) {
if(p) {
InThreading(p->lchild);
if(!p->lchild) {
p->ltag = Thread;
p->lchild = pre;
}
if(!pre->rchild) {
pre->rtag = Thread;
pre->rchild = p;
}
pre = p;
InThreading(p->rchild);
}
}
void InOrderThreading(ptree *Thrt,ptree pHead)
{
ptree pPre;
if(!((*Thrt)=(ptree)malloc(sizeof(TreeNode))))//initial
{
exit(-1);
}
(*Thrt)->Lflag=Link;
(*Thrt)->Rflag=Thread;
(*Thrt)->rightchild=(*Thrt);
if(!pHead)//if pHead is NULL
{
(*Thrt)->leftchild=(*Thrt);//point back
}
else
{
(*Thrt)->leftchild=pHead;
pPre=(*Thrt);
InThreading(pHead,&pPre);
pPre->rightchild=(*Thrt);
pPre->Rflag=Thread;
(*Thrt)->rightchild=pPre;
}
return ;
}
/*中序遍历二叉树T，并将其线索化，head为头指针
在线索二叉树中头结点lchild左孩子指向二叉树的根结点，
rchild右孩子指向中序遍历时访问的最后一个结点；
二叉树的中序遍历序列中第一个结点的lchild指针和最后一个孩子的rchild指向头结点
*/
void InOrderThreading(BiTree *head,BiTree T)
{
*head=(BiTree)malloc(sizeof(BiTNode));
if(!*head)/*如果创建失败*/
return;
/*初始化头结点*/
(*head)->LTag=Link;
(*head)->RTag=Thread;
(*head)->rchild=*head;/*头指针回指*/
if(!T)/*对传入第2个参数进行合法性检测，并采取相应处理,当T为空时*/
{
(*head)->lchild=(*head);
}
else
{
(*head)->lchild=T;//当T为非空时头结点指向二叉树的根结点T
pre=(*head);
InThreading(T);
/*对最后一个结点线索化*/
pre->RTag=Thread;
pre->rchild=*head;
(*head)->rchild=pre;/*头结点指向中序遍历最后一个结点*/
}
}
/* bo6-3.c 二叉树的二叉线索存储(存储结构由c6-3.h定义)的基本操作，包括算法6.5～6.7 */
void CreateBiThrTree(BiThrTree *T)
{ /* 按先序输入线索二叉树中结点的值，构造线索二叉树T。0(整型)/空格(字符型)表示空结点 */
TElemType ch;
scanf(form,&ch);
if(ch==Nil)
*T=NULL;
else
{
*T=(BiThrTree)malloc(sizeof(BiThrNode)); /* 生成根结点(先序) */
if(!*T)
exit(OVERFLOW);
(*T)->data=ch; /* 给根结点赋植 */
CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
if((*T)->lchild) /* 有左孩子 */
(*T)->LTag=Link; /* 给左标志赋值(指针) */
CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
if((*T)->rchild) /* 有右孩子 */
(*T)->RTag=Link; /* 给右标志赋值(指针) */
}
}
BiThrTree pre; /* 全局变量，始终指向刚刚访问过的结点 */
void InThreading(BiThrTree p)
{ /* 通过中序遍历进行中序线索化，线索化之后pre指向最后一个结点。算法6.7 */
if(p) /* 线索二叉树不空 */
{
InThreading(p->lchild); /* 递归左子树线索化 */
if(!p->lchild) /* 没有左孩子 */
{
p->LTag=Thread; /* 左标志为线索(前驱) */
p->lchild=pre; /* 左孩子指针指向前驱 */
}
if(!pre->rchild) /* 前驱没有右孩子 */
{
pre->RTag=Thread; /* 前驱的右标志为线索(后继) */
pre->rchild=p; /* 前驱右孩子指针指向其后继(当前结点p) */
}
pre=p; /* 保持pre指向p的前驱 */
InThreading(p->rchild); /* 递归右子树线索化 */
}
}
/*
中序遍历线索化
*/
void InThreading(BiThrTree T)
{
if(T==NULL)
return ;
InThreading(T->lchild);
printf("%c ", T->data);
if(T->lchild == NULL)
{
T->LTag = Thread;
T->lchild = pre;
}
if(pre->rchild == NULL)
{
pre->RTag = Thread;
pre->rchild = T;
}
pre = T;
InThreading(T->rchild);
}
/* 0(整型)/空格(字符型)表示空结点 */
TElemType h;
#if CHAR
scanf("%c",&h);
#else
scanf("%d",&h);
#endif
if(h==Nil)
*T=NULL;
else
{
*T=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*T)
exit(OVERFLOW);
(*T)->data=h; /* 生成根结点(先序) */
CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
if((*T)->lchild) /* 有左孩子 */
(*T)->LTag=Link;
CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
if((*T)->rchild) /* 有右孩子 */
(*T)->RTag=Link;
}
return OK;
}
BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
void InThreading(BiThrTree p)
{ /* 中序遍历进行中序线索化。*/
if(p)
{
InThreading(p->lchild); /* 递归左子树线索化 */
if(!p->lchild) /* 没有左孩子 */
{
p->LTag=Thread; /* 前驱线索 */
p->lchild=pre; /* 左孩子指针指向前驱 */
}
if(!pre->rchild) /* 前驱没有右孩子 */
{
pre->RTag=Thread; /* 后继线索 */
pre->rchild=p; /* 前驱右孩子指针指向后继(当前结点p) */
}
pre=p; /* 保持pre指向p的前驱 */
InThreading(p->rchild); /* 递归右子树线索化 */
}
}
/*
* 二叉树线索化中序递归函数
* 更改空指针
* */
void InThreading(BiThrTree p){
BiThrNode *pre;
if(p)
{
InThreading(p->lchild);
if(!p->lchild)
{
p->LTag=Thread;
p->lchild=pre;
}
if(!pre->rchild)
{
pre->RTag=Thread;
pre->rchild=p;
}
pre=p;
InThreading(p->rchild);
}
}
/*中序线索化*/
void InThreading(BiTree T)
{
if(T)
{
InThreading(T->lchild);
/*当没有左孩子时前驱线索*/
if(!T->lchild)
{
T->LTag=Thread;
T->lchild=pre;
}
/*当没有右孩子时后继线索*/
if(!pre->rchild)
{
pre->RTag=Thread;
pre->rchild=T;
}
pre=T;/* 保持pre指向前驱 */
InThreading(T->rchild);
}
}
void InThreading(ptree pHead,ptree *pPre)
{
ptree pCur=pHead;
//ptree (*pPre); //ptree (*pPre)=pCur (totally wrong no need to set value)
if(pCur)
{
InThreading(pCur->leftchild,pPre);
if(!pCur->leftchild)
{
pCur->Lflag=Thread;
pCur->leftchild=(*pPre);
}
if(!(*pPre)->rightchild)
{
(*pPre)->Rflag=Thread;
(*pPre)->rightchild=pCur;
}
(*pPre)=pCur;//mark the (*pPre)
InThreading(pHead->rightchild,pPre);
}
}
/* 中序遍历进行中序线索化 */
void InThreading(BiThrTree p)
{
if (p)
{
InThreading(p->lchild); // 递归遍历左子树
if (!p->lchild) // 如果该结点没有左孩子，则设置前驱
{
p->lchild = pre;
p->LTag = Thread; // 设置标记
}
if (!pre->rchild) // 如果它的前驱结点没有右孩子，则设置后继
{
pre->rchild = p;
pre->RTag = Thread; // 设置标记
}
pre = p; // 始终记录刚刚访问的结点
InThreading(p->rchild); // 递归遍历右子树
}
}
void InThreading(BiThrTree p)
{
BiThrTree pre;
if(p)
{
pre=p;//保存前驱结点
InThreading(p->lchild);//左子树线索化
if(!p->lchild)//前驱结点
{
p->LTag=Thread;
p->lchild=pre;
}
if(!pre->rchild)//后继结点
{
pre->RTag=Thread;
pre->lchild=p;
}
pre=p;//保持pre指向p的前驱
InThreading(p->rchild);//线索化右子树
}
}//InThreading
// 中序遍历线索化
void InThreading(BiTree T)
{
if( T )
{
InThreading(T->lchild); // 递归左孩子线索化
if( !T->lchild ) // 如果该节点没有左孩子，设置ltag为Thread，
// 并把lchild指向刚刚访问的结点
{
T->ltag = Thread;
T->lchild = pre;
}
if( !pre->rchild )
{
pre->rtag = Thread;
pre->rchild = T;
}
pre = T;
InThreading(T->rchild); // 递归又孩子线索化
}
}
int InOrderThreading(BiThrTree *Thrt,BiThrTree T) {
if(!(*Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
exit(-1);
(*Thrt)->ltag = Link;
(*Thrt)->rtag = Thread;
(*Thrt)->rchild = *Thrt;
if(!T)
(*Thrt)->lchild = *Thrt;
else {
(*Thrt)->lchild = T;
pre = *Thrt;
InThreading(T);
pre->rchild = *Thrt;
pre->rtag = Thread;
(*Thrt)->rchild = pre;
}
return 1;
}
Status InOrderThreading(BiThrTree *Thrt, BiThrTree T) {
*Thrt = (BiThrTree) malloc(sizeof(BiThrNode));
if (!*Thrt)
exit(OVERFLOW);
(*Thrt)->LTag = Link;
(*Thrt)->RTag = Thread;
(*Thrt)->rchild = *Thrt;
if (!T)
(*Thrt)->lchild = *Thrt;
else {
(*Thrt)->lchild = T;
pre = *Thrt;
InThreading(T);
pre->rchild = *Thrt;
pre->RTag = Thread;
(*Thrt)->rchild = pre;
}
return OK;
}
//test---------------
void test(void)
{
BiThrTree T;
CreateBiTree(&T);
// pre = T;
// PreOrderTraverse(T);
// printf("\n");
pre = T;
InThreading(T);
//InOrderTraverse_Thr(T);
printf("\n");
// pre = T;
// PostOrderTraverse(T);
// printf("\n");
}
void InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{ /* 中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。算法6.6 */
*Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*Thrt) /* 生成头结点不成功 */
exit(OVERFLOW);
(*Thrt)->LTag=Link; /* 建头结点，左标志为指针 */
(*Thrt)->RTag=Thread; /* 右标志为线索 */
(*Thrt)->rchild=*Thrt; /* 右指针回指 */
if(!T) /* 若二叉树空，则左指针回指 */
(*Thrt)->lchild=*Thrt;
else
{
(*Thrt)->lchild=T; /* 头结点的左指针指向根结点 */
pre=*Thrt; /* pre(前驱)的初值指向头结点 */
InThreading(T); /* 中序遍历进行中序线索化，pre指向中序遍历的最后一个结点 */
pre->rchild=*Thrt; /* 最后一个结点的右指针指向头结点 */
pre->RTag=Thread; /* 最后一个结点的右标志为线索 */
(*Thrt)->rchild=pre; /* 头结点的右指针指向中序遍历的最后一个结点 */
}
}
void InOrderThreading( BiTree *p, BiTree T )
{
*p = (BiTree)malloc(sizeof(BiTNode));
(*p)->ltag = Link;
(*p)->rtag = Thread;
(*p)->rchild = *p;
if( !T )
{
(*p)->lchild = *p;
}
else
{
(*p)->lchild = T;
pre = *p;
InThreading(T);
pre->rchild = *p;
pre->rtag = Thread;
(*p)->rchild = pre;
}
}
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{ /* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点。*/
*Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
if(!*Thrt)
exit(OVERFLOW);
(*Thrt)->LTag=Link; /* 建头结点 */
(*Thrt)->RTag=Thread;
(*Thrt)->rchild=*Thrt; /* 右指针回指 */
if(!T) /* 若二叉树空，则左指针回指 */
(*Thrt)->lchild=*Thrt;
else
{
(*Thrt)->lchild=T;
pre=*Thrt;
InThreading(T); /* 中序遍历进行中序线索化 */
pre->rchild=*Thrt;
pre->RTag=Thread; /* 最后一个结点线索化 */
(*Thrt)->rchild=pre;
}
return OK;
}
/*
* 二叉树线索化
* 添加头结点
* @param BiThrTree 为空指针，函数中分配空间，做线索二叉树的头结点
* @return failed -1 succeed 1
* */
Status InOrderThreading(BiThrTree Thrt,BiThrTree T)
{
BiThrNode *pre;
if(!(Thrt=(BiThrTree)malloc(sizeof(BiThrNode)))) //添加头结点
exit(OVERFLOW);
Thrt->LTag=Link;
Thrt->RTag=Thread;
Thrt->rchild=Thrt;
if(!T)
Thrt->lchild=Thrt;
else
{
Thrt->lchild=T;
pre=Thrt;
InThreading(T);
pre->rchild=Thrt;
pre->RTag=Thread;
Thrt->lchild=pre;
}
return OK;
}
//中序线索化二叉树
Status InOrderTraverse(BiThrTree &btt,BiThrTree T)
{
BiThrTree pre;
btt=(BiThrTree)malloc(sizeof(BiThrNode));
if(!btt)exit(OVERFLOW);//
//建立头结点
btt->LTag=Link;
btt->RTag=Link;
if(!T)btt->lchild=btt;//如果二叉树为空，则做指针回指
else
{
btt->lchild=T;
pre=btt;
InThreading(T);//中序遍历建立中序线索化
//将最后一个节点线索化
pre->rchild=btt;
pre->RTag=Thread;
btt->rchild=pre;
}
return OK;
}
