原文：https://subetter.com/algorith...
一：背景
线索二叉树的定义为：一个二叉树通过如下的方法“穿起来”：所有应该为空的右孩子指针指向该节点在中序序列中的后继，所有应该为空的左孩子指针指向该节点的中序序列的前驱。
那么在有N个节点的二叉树中共有N+1个空指针，这些空指针就叫做“线索”。（补充：在N个节点的二叉树中，每个节点有2个指针，所以一共有2N个指针，将这N个节点连接起来需要N-1条线，即使用了N-1个指针。所以剩下2N-(N-1)=N+1个空指针。）
那线索二叉树有何妙用呢？由于巧妙地利用了空指针，所以它可以快速地查找到二叉树中某节点的前驱和后继。接下来具体介绍这个数据结构。
在进行下文之前，约定如下：
struct Node
{
bool left_thread;
bool right_thread;
char data;
Node * left;
Node * right;
Node()
{
left_thread = right_thread = false;
data = 0;
left = right = nullptr;
}
};
class ThreadedBinaryTree
{
public:
ThreadedBinaryTree();
Node * create();
void threaded(Node * cur, Node *& pre); //线索化
void formLoop(); //构环
Node * get_successor(Node * node); //返回后继节点
Node * get_precursor(Node * node); //返回前驱节点
void in_order_print(); //中序遍历
private:
Node * _header; //头结点
Node * _root; //二叉树根节点
}; 请注意，在决定left是指向左孩子还是前驱，right是指向右孩子还是后继，我们是需要一个区分标志的。因此我们在Node结构体中增设两个布尔变量left_thread和right_thread，其中：
（1）left_thread为true时指向前驱，为false时指向该节点的左子树；
（2）right_thread为true时指向后继，为false时指向该节点的右子树。
二：具体实现与代码分析
2.1 构造二叉树
ThreadedBinaryTree::ThreadedBinaryTree()
{
_root = create();
}
Node * ThreadedBinaryTree::create()
{
Node * p = nullptr;
char ch;
cin >> ch;
if (ch == '.') //结束输入
p = nullptr;
else
{
p = new Node;
p->data = ch;
p->left = create();
p->right = create();
}
return p;
}递归构造一棵二叉树，这在二叉树基础已经讲过，不作解释。
2.2 线索化及二叉树构环
void ThreadedBinaryTree::threaded(Node * cur, Node *& pre)
{
if (cur == nullptr)
return;
else
{
//按照中序遍历方向，先处理左子树
threaded(cur->left, pre);
//再处理当前节点
if (cur->left == nullptr)
{
cur->left_thread = true;
cur->left = pre;
}
if (cur->right == nullptr)
cur->right_thread = true;
if (pre->right_thread)
pre->right = cur;
pre = cur;
//最后处理右子树
threaded(cur->right, pre);
}
}
void ThreadedBinaryTree::formLoop()
{
_header = new Node; //创建头结点，并完成初始化
_header->left_thread = true;
_header->right_thread = true;
_header->left = _header->right = _header;
Node * pre = _header; //记录中序遍历的前一个节点
threaded(_root, pre); //进行线索化
pre->right_thread = true; //线索化完后，把中序遍历的最后一个节点即pre，指向header
pre->right = _header;
_header->left = pre; //注意，header的左指针指向中序遍历的最后一个
} _header节点的作用就是把线索化后的二叉树串起来，形成一个环。_header的左孩子指向中序遍历序列的最后一个节点，右孩子指向中序遍历序列的第一个节点，如下图：
2.3 前驱和后继
Node * ThreadedBinaryTree::get_successor(Node * node)
{
if (node->right_thread)
return node->right;
Node * p = node->right;
while (p->left_thread == false) //已线索化，故此处只能用left_thread来判断左子树的情况
p = p->left;
return p;
}
Node * ThreadedBinaryTree::get_precursor(Node * node)
{
if (node->left_thread)
return node->left;
Node * p = node->left;
while (p->right_thread == false) //已线索化，故此处只能用right_thread来判断右子树的情况
p = p->right;
return p;
}2.4 中序遍历
void ThreadedBinaryTree::in_order_print()
{
cout << "中序遍历为：";
Node * p = _header->right; //header的右节点指向二叉树中序遍历的第一个节点
while (p != _header)
{
cout << p->data << " ";
p = get_successor(p);
}
cout << endl;
}三：完整代码
/**
*
* author 刘毅（Limer）
* date 2017-03-26
* mode C++
*/
#include
using namespace std;
struct Node
{
bool left_thread;
bool right_thread;
char data;
Node * left;
Node * right;
Node()
{
left_thread = right_thread = false;
data = 0;
left = right = nullptr;
}
};
class ThreadedBinaryTree
{
public:
ThreadedBinaryTree();
Node * create();
void threaded(Node * cur, Node *& pre); //线索化
void formLoop(); //构环
Node * get_successor(Node * node); //返回后继节点
Node * get_precursor(Node * node); //返回前驱节点
void in_order_print(); //中序遍历
private:
Node * _header; //头结点
Node * _root; //二叉树根节点
};
int main()
{
ThreadedBinaryTree my_tree;
my_tree.formLoop();
my_tree.in_order_print();
return 0;
}
ThreadedBinaryTree::ThreadedBinaryTree()
{
_root = create();
}
Node * ThreadedBinaryTree::create()
{
Node * p = nullptr;
char ch;
cin >> ch;
if (ch == '.') //结束输入
p = nullptr;
else
{
p = new Node;
p->data = ch;
p->left = create();
p->right = create();
}
return p;
}
void ThreadedBinaryTree::threaded(Node * cur, Node *& pre)
{
if (cur == nullptr)
return;
else
{
//按照中序遍历方向，先处理左子树
threaded(cur->left, pre);
//再处理当前节点
if (cur->left == nullptr)
{
cur->left_thread = true;
cur->left = pre;
}
if (cur->right == nullptr)
cur->right_thread = true;
if (pre->right_thread)
pre->right = cur;
pre = cur;
//最后处理右子树
threaded(cur->right, pre);
}
}
void ThreadedBinaryTree::formLoop()
{
_header = new Node; //创建头结点，并完成初始化
_header->left_thread = true;
_header->right_thread = true;
_header->left = _header->right = _header;
Node * pre = _header; //记录中序遍历的前一个节点
threaded(_root, pre); //进行线索化
pre->right_thread = true; //线索化完后，把中序遍历的最后一个节点即pre，指向header
pre->right = _header;
_header->left = pre; //注意，header的左指针指向中序遍历的最后一个
}
Node * ThreadedBinaryTree::get_successor(Node * node)
{
if (node->right_thread)
return node->right;
Node * p = node->right;
while (p->left_thread == false) //已线索化，故此处只能用left_thread来判断左子树的情况
p = p->left;
return p;
}
Node * ThreadedBinaryTree::get_precursor(Node * node)
{
if (node->left_thread)
return node->left;
Node * p = node->left;
while (p->right_thread == false) //已线索化，故此处只能用right_thread来判断右子树的情况
p = p->right;
return p;
}
void ThreadedBinaryTree::in_order_print()
{
cout << "中序遍历为：";
Node * p = _header->right; //header的右节点指向二叉树中序遍历的第一个节点
while (p != _header)
{
cout << p->data << " ";
p = get_successor(p);
}
cout << endl;
} 以（2.2）中的图为例，输入数据及测试结果为：