首先，什么是二叉树的线索化，为什么要对二叉树线索化？

二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。
为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息

n个节点的二叉树中含有n+1个空指针域。利用二叉树中的空指针域 来存放在某种遍历次序下的前驱和后继 ，这种指针叫“线索”。这种加上了线索的二叉树称为线索二叉树。

根据线索的性质的不同，线索二叉树分为：前序线索二叉树 ， 中序线索二叉树 ， 后序线索二叉树（本篇博客主要讲述前面两种 ， 后面会专门对后序线索二叉树分析 ）

                            线索二叉树节点：        

1. typedef enum
2. 2.{
3. 3. Link,
4. 4. Thread
5. 5.} PointTag;
6. 6.
7. 7.typedef struct BinaryTreeNode
8. 8.{
9. 9. BinaryTreeNode(const char data)
10. 10. :_data(data)
11. 11. , pLeft(NULL)
12. 12. , pRight(NULL)
13. 13. , Ltag(Link)
14. 14. , Rtag(Link)
15. 15. {}
16. 16. char _data;
17. 17. struct BinaryTreeNode *pLeft , * pRight;
18. 18. PointTag Ltag, Rtag;
19. 19.}BiTreeNode;

 Ltag  标记是否有左子树  ，  Ltag 是Link 则表示有左子树 ； Ltag是Thread表示没有左子树（有前驱）

 Rtag 标记是否有右子树  ，  Rtag是Link 则表示有右子树 ； Rtag是Thread 表示没有右子树（有后继）

首先，在线索化二叉树之前，你得有二叉树吧 还是 按之前的方式：先序创建二叉树

1. void _CreatTree(BiTreeNode*& Root, const char* arr, size_t size, size_t& index)
2. 2. {
3. 3. if (arr == NULL || size == 0)
4. 4. {
5. 5. cout << “输入有误 ” << endl;
6. 6. return;
7. 7. }
8. 8. if (index < size && arr[index] != \’#\’)
9. 9. {
10. 10. Root = new BiTreeNode(arr[index]);
11. 11. _CreatTree(Root->pLeft, arr, size, ++index);
12. 12. _CreatTree(Root->pRight, arr, size, ++index);
13. 13. }
14. 14. }

以下面的二叉树为例：

1、先序线索化二叉树和遍历
先序遍历的顺序：0 1 2 3 4

先序线索化二叉树

分析：首先对于左子树存在的节点，就不会有前驱；同样，节点的右子树存在，那么不存在后继。那么我就先一直找寻节的左子树，判断左右子树是否为空
，
为空了才会考虑前驱和后继的问题。后继倒是很好找（反正要遍历二叉树），那么前驱的位置呢？如果遇到左子树不存在的节点，怎么才能找到已经已经扫面过得节点呢？所以我们需要创建一个节点指针，每次记住上一次扫描的节点
。 对于右子树就很好办了 ， 如果当前节点的前一个节点不为空且右子树不存在，那么我们就放心大胆的链上吧 。然后循环得了。

假设 记录前一个节点的指针为：

BiTreeNode* Prev =NULL;

没听懂描述么？ 没关系，如果所示：

上代码：

1. void _PreOrderThreading(BiTreeNode*& Root)
2. {
3. if (Root == NULL)
4. {
5. return;
6. }
7. if (Root->pLeft == NULL) //没有左子树
8. {
9. Root->pLeft = Prev; //前驱
10. Root->Ltag = Thread;
11. }
12. if (Prev != NULL && Prev->pRight == NULL) // 上一个节点有没有 右子树
13. { //Prev第一次进来 为空
14. Prev->pRight = Root; //后继
15. Prev->Rtag = Thread;
16. }
17. Prev = Root;//前驱 ， 每次记住上次的节点
18.  
19. //判断Root是否有左右孩子
20. if (Root->Ltag == Link)
21. _PreOrderThreading(Root->pLeft);
22. if (Root->Rtag == Link)
23. _PreOrderThreading(Root->pRight);
24. }

对于先序线索二叉树，我想提醒的是：每次只会把当前节点的左子树前驱链上，这一次的 后继 不会在本次链上，当pCur指向下一个节点的时候，才会把上一次的后继链上

结果：

那么 怎么 写先序遍历线索二叉树呢

1. void _PreOrder(BiTreeNode* Root)
2. {
3. if (Root == NULL)
4. {
5. return;
6. }
7. BiTreeNode* pCur = Root;
8. while (pCur != NULL)
9. {
10. while (pCur->pLeft != NULL && pCur->Ltag == Link)//找到最左边的节点,左标记一直为Link
11. {
12. cout << pCur->_data << \’ \’;
13. pCur = pCur->pLeft;
14. }
15. //到这来，左边的的节点还没有访问
16. cout << pCur->_data << \’ \’;
17.  
18. if (pCur->Ltag == Thread)//遇到线索 就看右节点
19. {
20. pCur = pCur->pRight;
21. }
22. while (pCur != NULL)//循环右节点
23. {
24. if (pCur->pLeft != NULL && pCur->Ltag == Link)//遇到左节点存在 ， 则访问
25. {
26. break;
27. }
28. cout << pCur->_data << \’ \’;
29. pCur = pCur->pRight;
30. }
31. }
32. }

代码解释：

2、中序线索化二叉树和遍历

中序遍历的顺序：213 0 4

中序遍历线索化二叉树

分析：还是和先序很像的 ，中序的顺序是左-根-右，我们同样可以使用上面的递归方式；

话不多说，上代码：

1. void _InOrderThreading(BiTreeNode*& Root)
2. {
3. if (Root == NULL)
4. {
5. return;
6. }
7. _InOrderThreading(Root->pLeft); // 左
8.  
9. if (Root->pLeft == NULL) //根
10. {
11. Root->Ltag = Thread;
12. Root->pLeft = Prev;
13. }
14. if (Prev != NULL && Prev->pRight == NULL)
15. {
16. Prev->pRight = Root;
17. Prev->Rtag = Thread;
18. }
19. Prev = Root;
20. _InOrderThreading(Root->pRight); //右
21. }

中序遍历线索二叉树

1. void _InOrder(BiTreeNode* Root)
2. {
3. if (Root == NULL)
4. {
5. return;
6. }
7. BiTreeNode* pCur = Root;
8. while (pCur )
9. {
10. while (pCur->Ltag == Link) //找最左边的节点
11. {
12. pCur = pCur->pLeft;
13. }
14. cout << pCur->_data << \’ \’;
15. while ( pCur && pCur->Rtag == Thread )//找中序后继节点
16. {
17. pCur = pCur->pRight;
18. cout << pCur->_data << \’ \’;
19. }
20. //没有后继，有右子树
21. pCur = pCur->pRight;
22. }
23. }

其实，中序遍历和先序遍历二叉树还是很像的，首先按照中序遍历的顺序，找到二叉树的最左边的节点，判断是否有前驱，有则遍历访问，没有则看右子树和后继的情况。

此处，可以按照之前的画图过程继续一步步来。

全部代码：