C语言线索二叉树

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_40667484/article/details/80902285

线索二叉树步骤：

1、创建二叉树

2、中序遍历线索化

对每一个结点进行操作

（1）、无左孩子：Lsign为1，指向前驱

（2）、无右孩子：Rsign为1，指向后继（想完成此操作需要设置一个全局变量pre指向刚刚访问过的结点）

3、创建一个头结点，左子树指向根结点，右子树指向最后一个结点。

4、中序遍历二叉线索链表表示的二叉树T

typedef struct node
{
 char data;
 struct node *lchild;
 struct node *rchild;
 int lsign;
 int rsign;
}Bintree;
Bintree *pre;

#include<stdio.h>
#include<stdlib.h>
#include"list.h"

Bintree *Createtree()
{
 Bintree *p;
 char ch;
 scanf("%c",&ch);

 if(ch=='*')
 {
  p=NULL;
 }
 else
 {
  p=(Bintree *)malloc(sizeof(Bintree));
  p->data=ch;
  p->lsign=0;      
  p->rsign=0;      
  p->lchild=Createtree();
  p->rchild=Createtree();
 }
 return p;
}
}
void InThreading(Bintree *p)   //中序线索化遍历             
{
 if(p)
 {
  InThreading(p->lchild);                                //递归思想遍历到最左边一层H，先对H进行操作，    其次D
  if(!p->lchild)             //没左孩子记录前驱
  {
   p->lsign=1;     
   p->lchild=pre;                        //pre记录为p的前驱,最开始为头结点       
  }
  if(!pre->rchild)          //没右孩子记录后继
  {
   pre->rsign=1;
   pre->rchild=p;
  }
  pre=p;                                       //操作完后pre重新指回p的前驱
  InThreading(p->rchild);
 }
}
Bintree *InOrderThreading(Bintree *T)    //带头结点的二叉树中序线索化
{ 
 Bintree *Thrt;                                                                  //创建头结点
 Thrt=(Bintree *)malloc(sizeof(Bintree));
 Thrt->lsign=0;
 Thrt->rsign=1;
 Thrt->rchild=Thrt;        
 if(!T)
 {
   Thrt->lchild=Thrt;
 }
 else
 {
  Thrt->lchild=T; 
  pre=Thrt;                                                             //对H进行操作，pre指向头结点,为H的前驱

  InThreading(T);    //执行完后pre指向了T最右一个节点，右子树为空
  Thrt->rchild=pre;
  pre->rsign=1;
  pre->rchild=Thrt;
 }
 return Thrt;
}
void InOrderTraverse_Thr(Bintree *T)           //中序遍历二叉线索链表表示的二叉树T
{
 Bintree *p;
 p=T->lchild;
 while(p!=T)
 {
  while(p->lsign==0)
  {
   p=p->lchild;                                                        //从H开始遍历
  }
  printf("%c",p->data);
  while(p->rsign==1&&p->rchild!=T)
  {
   p=p->rchild;
   printf("%c",p->data);
  }
  p=p->rchild;
 }
}
int main()
{
 Bintree *h;
 h=Createtree();
 h=InOrderThreading(h);
 InOrderTraverse_Thr(h);
 return 0;
}

顺序基本上是头结点->H->D->I->B...P->头结点