【数据结构】线索二叉树

一、线索二叉树基本概念

1、概念 

     二叉链表的存储结构，只能找到该结点的左右孩子，不能得到该结点在遍历过程中的遍历前驱和直接后继结点。二叉链表存储二叉树时，有2n个指针域，其中n+1个都为空指针域。

利用空指针域存储结点遍历过程中的前驱和后继结点，使结点之间组成联系，在遍历的过程中可以不用通过栈或递归。

线索 二叉树的作用：

将树转换成线性链表，二叉树在首次遍历中线索化，在需要时可以直接获得结点的前驱和后继，不需要像栈一样频繁的压栈出栈。

2、线索二叉树的结构

线索二叉树与二叉链表的区别是，增加了左标志域Ltag，和右标志域Rtag，，是两个布尔值的数据域。线索二叉树的结构为：

1、若结点的左孩子不为空，LChild指针域仍指向其左孩子，否则，LChild指针域指向遍历过程序列的前驱结点。

2、若结点的右孩子不为空，RChild指针域仍指向其右孩子，否则，RChild指针域指向遍历过程序列的后继结点。

3、对于Ltag和Rtag的标志域的定义：

   Ltag = 0时，LChild域指向结点的左孩子。

   Ltag=1时， LChild域指向结点的遍历前驱。

   Rtag=0时，RChild域指向结点的右孩子。

   Rtag=1时，RChild域指向结点的遍历后继。

1. typedef struct Node

2. {

3. TypeData data;

4. int Ltag,Rtag;

5. struct Node*LChild;

6. Struct Node*RChild;

7. }BiTree,*BiThrTree;

3、名词解释

线索：指向前驱和后继结点的指针

线索化：对二叉树以先序次序（中序，后序）遍历的过程中将结点的空指针域改为线索的过程，叫做‘线索化’。

线索二叉树：经过线索化的二叉树。

线索链表：以线索二叉树的结点结构存储的含有线索的二叉链表

二、线索二叉树的线索化

1、原理

线索化的过程就是在遍历的过程中将二叉树中空的指针域填上结点的直接前驱或直接后继的过程。

1.1如何实现空指针域中结点的前驱或后继

     结点空指针域前驱的填入，需要知道刚刚访问的结点，后继的填入，需要知道下一个访问的结点，所以可以用一个 pre 指针专门用于记录刚刚访问的结点（也就是现在访问的结点的上一个结点。

     对于 pre 指针，因为开始遍历的第一个结点没有前驱，所以 pre 需要初始化为NULL。

对于空指针域结点的前驱的填入思路：

     如果当前访问的结点的左子树为空，此时指向左子树的指针域为空，让其指向刚刚访问过的结点pre，root->LChild=pre 同时将左标志域 Ltag 置为 1 ，即完成了前驱线索。

对于后继的填入思路:

      结点的右子树为空，指向其右子树的指针域为空，让其指向下一个结点，就需要知道下一个结点的存在才能进行连接。所以需要在遍历到下一个结点时，让刚访问过的结点 pre 进行回填指向右孩子的指针域。

      pre是刚访问过的结点，判断pre的右孩子是否为空，为空时：root是当前访问的结点，对pre的右孩子指针域进行回填，让pre->RChild=root,且将右标志域Rtag 置为1。

1.2 图解便于理解

2、算法实现

二叉树的中序线索化算法

1. //中序线索化算法

2. void Inthread(BiTree root)

3. {

4. if(root!=NULL)

5. {

6. Inthread(root->LChild); //通过递归线索化左子树

7. if(root->LChild==NULL) //当前结点的左子树为空

8. {

9. root->LChild=pre; // 第一步 置前驱线索

10. root->Ltag=1; //左标志域为1

11. }

12. if(pre!=NULL&&pre->RChild==NULL) //刚刚访问的结点不为空且右子树为空

13. {

14. pre->RChild=root; // 第二步 置后驱线索

15. pre->Rtag=1; //右标志域为1

16. }

17. pre=root; // 第三步 pre指向当前访问的结点

18. Inthread(root->RChild); //递归线索化右子树

19. }

20. }

三、线索二叉树的遍历

线索二叉树的遍历过程分为两步：

1、第一步找到遍历过程中的第一个被访问的结点。

2、第二步是不断在遍历的过程中寻找刚访问结点的后继结点，并访问。

1、中序线索二叉树中寻找遍历的首结点 

中序次序是先访问左子树，根结点、右子树。所以中序遍历的首结点是左子树的最左下端的结点。

1. BiThrTree InFirst(BiThrTree bt)

2. {

3. BiThrTree p=bt;

4. if(p==NULL)

5. return NULL;

6. while(p->Ltag==0)

7. p=p->LChild;

8. return p;

9. }

2、寻找结点的直接后继

要找 p 结点的后继，需要进入其右子树，p结点的后继结点是右子树中遍历的第一个结点也就是左子树中的最左下端。

1. BiThrTree InNext（BiThrTree p）

2. {

3. if(p->Rtag==1) //如果p的右子树为空，直接利用线索找到其后继结点。

4. next=p->RChild;

5. else //在p的右子树中找左子树的第一个结点

6. {

7. next=p->RChild;

8. while(next->Ltag==0) //结点的左子树指向下一个结点时，继续找最左下端的左子树

9. next=next->LChild;

10. }

11. return next;

12. }

3、遍历线索二叉树

按照线索二叉树遍历的两步走

1. void TinOrder(BiThrTree root)

2. {

3. BiThrTree p;

4. p=InFirst(root);

5. while(p!=NULL)

6. {

7. Visit(p->data);

8. p=InNext(p);

9. }

10. }

四、线索二叉树遍历的应用

算法实现：

1. #include<stdio.h>

2. #include<stdlib.h>

3. //定义结点结构

4. typedef struct Node

5. {

6. char data;

7. int Ltag, Rtag;

8. struct Node* LChild;

9. struct Node* RChild;

10. }BiTreeNode,*BiThrTree;

11. //建立二叉链表

12. void Establish(BiThrTree* root)

13. {

14. char demo;

15. demo = getchar();

16. if (demo == '^')

17. *root = NULL;

18. else

19. {

20. *root = (BiThrTree)malloc(sizeof(BiTreeNode));

21. if (*root == NULL)

22. return;

23. (*root)->data = demo;

24. (*root)->Ltag = 0;

25. (*root)->Rtag = 0;

26. Establish(&((*root)->LChild));

27. Establish(&((*root)->RChild));

28. }

29. }

30. //线索化，建立线索链表

31. void Inthread(BiThrTree*root)

32. {

33. static BiThrTree pre = NULL; //在递归调用中，初始化pre，且保存每次pre的信息，用static静态局部变量解决

34. if ((*root) != NULL)

35. {

36. Inthread(&((*root)->LChild));

37. if ((*root)->LChild == NULL)

38. {

39. (*root)->LChild = pre;

40. (*root)->Ltag = 1;

41. }

42. if (pre != NULL && pre->RChild == NULL)

43. {

44. pre->RChild = (*root);

45. pre->Rtag = 1;

46. }

47. pre = (*root);

48. Inthread(&((*root)->RChild));

49. }

50. }

51. //查找遍历的首结点

52. BiThrTree InFirst(BiThrTree root)

53. {

54. BiThrTree p=root;

55. if (p == NULL)

56. return NULL;

57. while(p->Ltag == 0)

58. p = p->LChild;

59. return p;

60. }

61. //查找遍历过程中结点的直接后继

62. BiThrTree InNext(BiThrTree p)

63. {

64. BiThrTree next=NULL;

65. if (p->Rtag == 1)

66. next = p->RChild;

67. else

68. {

69. next= p->RChild;

70. while (next!=NULL&&next->Ltag == 0) //next!=NULL,解决局部变量next为空指针时，不能访问data等数据

71. next = next->LChild;

72. }

73. return next;

74. }

75. //遍历线索二叉树

76. void TinOrder(BiThrTree root)

77. {

78. BiThrTree p;

79. if (root == NULL)

80. return;

81. p = InFirst(root);

82. while (p != NULL)

83. {

84. printf("%c ", p->data);

85. p = InNext(p);

86. }

87. }

88. main()

89. {

90. BiThrTree root;

91. printf("------根据二叉链表的格式输入结点数据------\n");

92. printf("\n");

93. Establish(&root);

94. Inthread(&root);

95. printf("-------遍历打印线索二叉树-------\n");

96. printf("\n");

97. TinOrder(root);

98. }

运行结果：