线索二叉树

转自：http://blog.csdn.net/zhaoxianyong/article/details/7170297

好文分享，感谢原博主zhaoxianyong

正文：

一、线索二叉树

        遍历二叉树实际上是将树中的结点按照一定的规则构成一个线性序列，不同的遍历方式得到的是不同的序列。对于需要经常遍历的二叉树，可以充分利用二叉树的空指针域，保存遍历中的信息，即左右指针分别记录结点的前驱和后继，即二叉树的线索化。

        重新定义二叉树结点如下，增加两个标志域：

[html] view plaincopy

1. typedef enum PointerTag{Link, Thread};  
2. struct BiTreeThreadNode{  
3.     int c;  
4.     struct BiTreeThreadNode *left;  
5.     struct BiTreeThreadNode *right;  
6.     PointerTag ltag,rtag;  
7. };  

二、二叉树的线索化

1、带标志域的二叉树的先序输入递归创建如下：（注意要给标志域赋值，因为在遍历时需要判断标志域）

[cpp] view plaincopy

1. //先序输入递归创建二叉树  
2. BiTreeThreadNode* createBiTreeThreadPreOrder()  
3. {  
4.     BiTreeThreadNode *ptree=NULL;  
5.     char ch;  
6.     ch=getchar();  
7.     if(ch==' ')  
8.         ptree=NULL;  
9.     else  
10.     {  
11.         ptree=(struct BiTreeThreadNode *)malloc(sizeof(BiTreeThreadNode));  
12.         ptree->c=ch;  
13.         ptree->left=createBiTreeThreadPreOrder();  
14.         ptree->right=createBiTreeThreadPreOrder();  
15.         ptree->ltag=ptree->left?Link:Thread;  
16.         ptree->rtag=ptree->right?Link:Thread;  
17.     }  
18.     return ptree;  
19. }  

2、二叉树的中序线索化

        二叉树的中序线索化可以通过中序遍历实现，遍历方式可以选用递归或者非递归，这里采用递归方式，非递归方式可以参考非递归中序遍历。

        在线索化二叉树时，先线索化其左子树，再处理其根结点，最后线索化其右子树。见函数InThreading。

        根结点处理的方式为：若其左子树为空，则使左指针指向其前驱pre；若前驱pre的右子树为空，则指向该根结点（pre的后继）。其中，pre为全局结构体指针，始终指向前一次访问过的结点。

        为了方便线索二叉树的遍历，给二叉树添加一头结点：其左指针指向线索二叉树的根结点，右指针指向线索二叉树的最后一个结点，且线索二叉树的第一个结点的左指针和最后一个结点的右指针均指向该头结点。为方便遍历，若二叉树为空树，将头结点的左指针指向自身。见函数InOrderThreading。

[cpp] view plaincopy

1. BiTreeThreadNode *pre=NULL;  
2. BiTreeParentThreadNode *pre2=NULL;  
3. //递归中序遍历实现中序线索化  
4. void InThreading(BiTreeThreadNode *ptree)  
5. {  
6.     if(ptree)  
7.     {  
8.         InThreading(ptree->left);  
9.         if(!ptree->left) { ptree->ltag=Thread; ptree->left=pre;}  
10.         if(!pre->right) { pre->rtag=Thread; pre->right=ptree; }  
11.         pre=ptree;  
12.         InThreading(ptree->right);  
13.     }  
14. }  
15. BiTreeThreadNode* InOrderThreading(BiTreeThreadNode *ptree)  
16. {  
17.     BiTreeThreadNode *pthr=NULL;  
18.     pthr=(BiTreeThreadNode *)malloc(sizeof(BiTreeThreadNode));  
19.     pthr->ltag=Link;  
20.     pthr->rtag=Thread;  
21.     pthr->right=pthr;  
22.     if(!ptree) pthr->left=pthr;  
23.     else  
24.     {  
25.         pthr->left=ptree;  
26.         pre=pthr;  
27.         InThreading(ptree);  
28.         pre->right=pthr;  
29.         pre->rtag=Thread;  
30.         pthr->right=pre;  
31.     }  
32.     return pthr;  
33. }  

3、二叉树的先序线索化

        类似地，二叉树的先序线索化可以通过递归先序遍历实现。

        先处理根结点，再线索化其左子树，最后线索化其右子树，见函数PreThreading。

        根结点的处理方式为：若其左子树为空，则使左指针指向其前驱pre；若前驱pre的右子树为空，则指向该根结点（pre的后继）。其中，全局结构体指针pre始终指向前一次访问过的结点。此时应注意的是：当左子树为空时，左指针会指向其前驱，而不再为NULL，此时线索化左子树会无限递归，导致栈溢出；当右子树为空时，先进行的左子树的线索化会使此时的右指针指向其后继，不再为NULL，导致右子树的线索化无限递归以致栈溢出。考虑到这一点，增加一条件，即左/右子树为空时，不进行线索化。

        同样地，为了方便遍历，添加一头结点，见函数PreOrderThreading。

[cpp] view plaincopy

1. //递归先序遍历实现先序线索化  
2. void PreThreading(BiTreeThreadNode *ptree)  
3. {  
4.     if(ptree)  
5.     {  
6.         if(!ptree->left) { ptree->ltag=Thread; ptree->left=pre;}  
7.         if(!pre->right) { pre->rtag=Thread; pre->right=ptree; }  
8.         pre=ptree;  
9.         if(ptree->ltag==Link) PreThreading(ptree->left);     
10.         if(ptree->rtag==Link) PreThreading(ptree->right);  
11.     }  
12. }  
13. BiTreeThreadNode* PreOrderThreading(BiTreeThreadNode *ptree)  
14. {  
15.     BiTreeThreadNode *pthr=NULL;  
16.     pthr=(BiTreeThreadNode *)malloc(sizeof(BiTreeThreadNode));  
17.     pthr->ltag=Link;  
18.     pthr->rtag=Thread;  
19.     pthr->right=pthr;  
20.     if(!ptree) pthr->left=pthr;  
21.     else  
22.     {  
23.         pthr->left=ptree;  
24.         pre=pthr;  
25.         PreThreading(ptree);  
26.         pre->right=pthr;  
27.         pre->rtag=Thread;  
28.         pthr->right=pre;  
29.     }  
30.     return pthr;  
31. }  

4、二叉树的后序线索化
        后序线索树的遍历需要知道节点的双亲（后面将看到），因而为结点添加一指向双亲的指针域，重新定义二叉树如下：

[cpp] view plaincopy

1. struct BiTreeParentThreadNode{  
2.     int c;  
3.     struct BiTreeParentThreadNode *parent;  
4.     struct BiTreeParentThreadNode *left;  
5.     struct BiTreeParentThreadNode *right;  
6.     PointerTag ltag,rtag;  
7. };  

        相应的先序输入递归创建函数如下：（注意为自身的双亲指针赋初值NULL，将子树的双亲指针指向自身，这样除根结点外，每个结点均指向其双亲）

[cpp] view plaincopy

1. //先序输入递归创建三叉链表式二叉树  
2. BiTreeParentThreadNode* createBiTreeParentThreadPreOrder()  
3. {  
4.     BiTreeParentThreadNode *ptree=NULL;  
5.     char ch;  
6.     ch=getchar();  
7.     if(ch==' ')  
8.         ptree=NULL;  
9.     else  
10.     {  
11.         ptree=(struct BiTreeParentThreadNode *)malloc(sizeof(BiTreeParentThreadNode));  
12.         ptree->c=ch;  
13.         ptree->parent=NULL;  
14.         ptree->left=createBiTreeParentThreadPreOrder();  
15.         ptree->right=createBiTreeParentThreadPreOrder();  
16.         ptree->ltag=ptree->left?Link:Thread;  
17.         ptree->rtag=ptree->right?Link:Thread;  
18.         if(ptree->left) ptree->left->parent=ptree;  //左子树根的双亲节点  
19.         if(ptree->right) ptree->right->parent=ptree;  //右子树根的双亲节点  
20.     }  
21.     return ptree;  
22. }  

        二叉树的后序线索化可以通过递归后序遍历实现。

        先线索化其左子树，再线索化其右子树，最后处理根结点，见函数PostThreading。

        根结点的处理方式为：若其左子树为空，则使左指针指向其前驱pre；若前驱pre的右子树为空，则指向该根结点（pre的后继）。其中，全局结构体指针pre始终指向前一次访问过的结点。由于左右子树的线索化先于根结点处理，故不会出现先序线索化时的无限递归情况。

        同样地，添加一头结点，为了方便遍历，使根结点的双亲指针指向头结点，见函数PostOrderThreading。

[cpp] view plaincopy

1. //递归后序遍历实现后序线索化  
2. BiTreeParentThreadNode *pre2=NULL;  
3. void PostThreading(BiTreeParentThreadNode *ptree)  
4. {  
5.     if(ptree)  
6.     {  
7.         PostThreading(ptree->left);  
8.         PostThreading(ptree->right);  
9.         if(!ptree->left) { ptree->ltag=Thread; ptree->left=pre2;}  
10.         if(!pre2->right) { pre2->rtag=Thread; pre2->right=ptree; }  
11.         pre2=ptree;  
12.           
13.     }  
14. }  
15. BiTreeParentThreadNode* PostOrderThreading(BiTreeParentThreadNode *ptree)  
16. {  
17.     BiTreeParentThreadNode *pthr=NULL;  
18.     pthr=(BiTreeParentThreadNode *)malloc(sizeof(BiTreeParentThreadNode));  
19.     pthr->ltag=Link;  
20.     pthr->rtag=Thread;  
21.     pthr->right=pthr;  
22.     if(!ptree) pthr->left=pthr;  
23.     else  
24.     {  
25.         pthr->left=ptree;  
26.         ptree->parent=pthr;  
27.         pre2=pthr;  
28.         PostThreading(ptree);  
29.         pre2->right=pthr;  
30.         pre2->rtag=Thread;  
31.         pthr->right=pre2;  
32.     }  
33.     return pthr;  
34. }  

 

三、线索二叉树的遍历

        二叉树线索化后，原来的左/右空指针指向了结点的前驱或后继，形成了一个线性序列，其遍历可以从最首结点开始，依次寻找“后继”，直到最末结点。但是，对于右指针不为空的结点，无法通过后继指针直接索引到其后继结点。这就需要根据不同的线索化顺序，以不同的方式找到其后继结点。线索二叉树的遍历中，寻找后继结点是关键。

1、中序线索二叉树的中序遍历

        对于中序线索二叉树：树的最首结点为“最左下”的结点；若当前结点不存在右子树，则其后继结点可通过右指针直接找到；否则，其后继为其右子树的“最左下”结点。代码如下：

[cpp] view plaincopy

1. //中序线索二叉树的中序遍历--实现方式一  
2. int InOrderTraverseBiTreeThread(BiTreeThreadNode *pthr,int (*visit)(int))  
3. {  
4.     BiTreeThreadNode *pt=NULL;  
5.     pt=pthr->left;  
6.     if(pt!=pthr)  
7.         while(pt->ltag==Link) pt=pt->left;  
8.     while(pt!=pthr)  
9.     {  
10.         visit(pt->c);  
11.         if(pt->rtag==Thread) pt=pt->right;  
12.         else  
13.         {  
14.             pt=pt->right;  
15.             while(pt->ltag==Link) pt=pt->left;  
16.         }  
17.     }  
18.     return 1;  
19. }  
20. //中序线索二叉树的中序遍历--实现方式二  
21. int InOrderTraverseBiTreeThread2(BiTreeThreadNode *pthr,int (*visit)(int))  
22. {  
23.     BiTreeThreadNode *pt=NULL;  
24.     pt=pthr->left;  
25.     while(pt!=pthr)  
26.     {  
27.         while(pt->ltag==Link) pt=pt->left;  
28.         visit(pt->c);  
29.         while(pt->rtag==Thread && pt->right!=pthr)  
30.         {  
31.             pt=pt->right;  
32.             visit(pt->c);  
33.         }  
34.         pt=pt->right;  
35.     }  
36.     return 1;  
37. }  

2、先序线索二叉树的先序遍历

        对于先序线索二叉树：树的最首结点为树的根结点；若当前结点不存在右子树，则其后继结点可通过右指针直接找到；否则，若存在左子树则其后继为其左子树的根结点，若不存在左子树则其后继为其右子树的根结点。代码如下：

[cpp] view plaincopy

1. //先序线索二叉树的先序遍历  
2. int PreOrderTraverseBiTreeThread(BiTreeThreadNode *pthr,int (*visit)(int))  
3. {  
4.     BiTreeThreadNode *pt=NULL;  
5.     pt=pthr->left;  
6.     while(pt!=pthr)  
7.     {  
8.         visit(pt->c);  
9.         if(pt->rtag==Thread) pt=pt->right;  
10.         else if(pt->ltag==Link) pt=pt->left;  
11.         else pt=pt->right;  
12.     }  
13.     return 1;  
14. }  

3、后序线索二叉树的后序遍历

        对于后序线索二叉树：树的最首结点为“最左下”的结点；若当前结点不存在右子树，则其后继结点可通过右指针直接找到；否则考虑其双亲，若当前结点为其双亲的右子树或其双亲不存在右子树，则其后继结点为其双亲，若当前结点为其双亲的左子树且双亲存在右子树，则其后继结点为其双亲右子树的“最左下”结点。代码如下：

[cpp] view plaincopy

1. //后序线索二叉树的后序遍历  
2. int PostOrderTraverseBiTreeParentThread(BiTreeParentThreadNode *pthr,int (*visit)(int))  
3. {  
4.     BiTreeParentThreadNode *pt=NULL;  
5.     pt=pthr->left;  
6.     if(pt!=pthr)  
7.         while(pt->ltag==Link) pt=pt->left;  
8.     while(pt!=pthr)  
9.     {  
10.         visit(pt->c);  
11.         if(pt->rtag==Thread) pt=pt->right;  
12.         else if(pt==pt->parent->right || pt->parent->rtag==Thread)  
13.             pt=pt->parent;  
14.         else  
15.         {  
16.             pt=pt->parent->right;  
17.             while(pt->ltag==Link) pt=pt->left;  
18.         }  
19.     }  
20.     return 1;  
21. }