线索化二叉树

对于n个结点的二叉树，在二叉链存储结构中有n+1个空链域，利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。

这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。

注意：
线索链表解决了无法直接找到该结点在某种遍历序列中的前趋和后继结点的问题，出现了二叉链表找左、右孩子困难的问题。

二叉树的遍历本质上是将一个复杂的非线性结构转换为线性结构，使每个结点都有了唯一前驱和后继（第一个结点无前驱，最后一个结点无后继）。对于二叉树的一个结点，查找其左右子女是方便的，其前驱后继只有在遍历中得到。为了容易找到前驱和后继，有两种方法。一是在结点结构中增加向前和向后的指针fwd和bkd，这种方法增加了存储开销，不可取；二是利用二叉树的空链指针。现将二叉树的结点结构重新定义如下：

其中：ltag=0 时lchild指向左子女；
ltag=1 时lchild指向前驱；
rtag=0 时rchild指向右子女；
rtag=1 时rchild指向后继；

建立线索二叉树，或者说对二叉树线索化，实质上就是遍历一棵二叉树。在遍历过程中，访问结点的操作是检查当前的左，右指针域是否为空，将它们改为指向前驱结点或后续结点的线索。为实现这一过程，设指针pre始终指向刚刚访问的结点，即若指针p指向当前结点，则pre指向它的前驱，以便设线索。

另外，在对一颗二叉树加线索时，必须首先申请一个头结点，建立头结点与二叉树的根结点的指向关系，对二叉树线索化后，还需建立最后一个结点与头结点之间的线索。

#include <iostream>
using namespace std;

enum PointFlag{LINK, THREAD};

template<class T>
struct BinaryTreeNodeThd
{
    BinaryTreeNodeThd(const T& data)
        : _data(data)
        , _pLeft(NULL)
        , _pRight(NULL)
        , _leftThread(LINK)
        , _rightThread(LINK)
    {}

    T _data;
    BinaryTreeNodeThd<T>* _pLeft;
    BinaryTreeNodeThd<T>* _pRight;
    PointFlag _leftThread;
    PointFlag _rightThread;
};

template<class T>
class BinaryTreeThd
{
    typedef BinaryTreeNodeThd<T> Node;
public:
    BinaryTreeThd()
        : _pRoot(NULL)
    {}

    BinaryTreeThd(const T array[], size_t size, const T& invalid)
    {
        size_t index = 0;
        _CreateTree(_pRoot, array, size, index, invalid);
    }

    void PreThreading() //前序线索化
    {
        Node* prev = NULL;
        _PreThreading(_pRoot, prev);
    }

    void InThreading()  //中序线索化
    {
        Node* prev = NULL;
        _InThreading(_pRoot, prev);
    }

    void PostThreading()  //后序线索化
    {
        Node* prev = NULL;
        _PostThreading(_pRoot, prev);
    }

    void PreOrder()    //前序遍历
    {
        if(_pRoot == NULL)
            return;

        Node* pCur = _pRoot;
        while(pCur)
        {
            //找最左边节点，访问路径上经过的所有节点
            while(pCur->_leftThread == LINK)
            {
                cout<<pCur->_data<<" ";
                pCur = pCur->_pLeft;
            }
            cout<<pCur->_data<<" "; //访问最左边节点

            //判断当前节点是否有右子树，没有右子树，循环访问后继结点
            while(pCur->_rightThread == THREAD)
            {
                pCur = pCur->_pRight;
                cout<<pCur->_data<<" ";
            }

            if(pCur->_leftThread == LINK)
                //有右子树，当作新树，开始处理
                pCur = pCur->_pLeft;

            if(pCur->_rightThread == LINK)
                pCur = pCur->_pRight;
        }
    }

    void InOrder() //中序遍历
    {
        if(_pRoot == NULL)
            return;
        Node* pCur = _pRoot;
        while(pCur)
        {
            //找到最左边节点，但并不访问
            while(pCur->_leftThread == LINK)
                pCur = pCur->_pLeft;

            //访问最左边节点
            cout<<pCur->_data<<" ";
            //判断当前节点有没右孩子，没有右孩子，访问，取后继结点
            while(pCur->_rightThread == THREAD)
            {
                pCur = pCur->_pRight;
                cout<<pCur->_data<<" ";
            }
                pCur = pCur->_pRight;
        }
    }

private:
    void _CreateTree(Node* &pRoot, const T array[], size_t size, 
        size_t& index, const T& invalid)
    {
        if(index < size && (array[index] != invalid))//两个顺序不可调换，否则会导致越界访问
        {
            //创建根节点
            pRoot = new Node(array[index]);

            //创建根结点左子树
            _CreateTree(pRoot->_pLeft, array, size, ++index, invalid);


            //创建根结点左子树
            _CreateTree(pRoot->_pRight, array, size, ++index, invalid);
        }
    }

    void _PreThreading(Node* pRoot, Node*& prev)
    {
        if(pRoot)
        {
            //线索化当前节点左指针域
            if(pRoot->_pLeft == NULL)
            {
                pRoot->_pLeft = prev;
                pRoot->_leftThread = THREAD;
            }

            //线索化前一结点的右指针域
            if(prev && prev->_pRight == NULL)
            {
                prev->_pRight = pRoot;
                prev->_rightThread = THREAD;
            }
            prev = pRoot;

            if(pRoot->_leftThread == LINK)
                _PreThreading(pRoot->_pLeft, prev);

            if(pRoot->_rightThread == LINK)
                _PreThreading(pRoot->_pRight, prev);
        }
    }

    void _InThreading(Node* pRoot, Node*& prev)
    {
        if(pRoot)
        {
            if(pRoot->_leftThread == LINK)
                _InThreading(pRoot->_pLeft, prev);


            //线索化当前节点左指针域
            if(pRoot->_pLeft == NULL)
            {
                pRoot->_pLeft = prev;
                pRoot->_leftThread = THREAD;
            }
            //线索化当前一节点的右指针域
            if(prev && prev->_pRight == NULL)  //先保证有右孩子的存在
            {
                prev->_pRight = pRoot;
                prev->_rightThread = THREAD;
            }
            prev = pRoot;

            //if(pRoot->_rightThread == LINK)
                _InThreading(pRoot->_pRight, prev);
        }
    }


private:
    Node* _pRoot;
};


void FunTest()
{
    char array[] = "124##5##36##7##";
    BinaryTreeThd<char> tree(array, strlen(array), '#');
    /*tree.PreThreading();
    tree.PreOrder();*/
    /*tree.InThreading();
    tree.InOrder();*/
}

int main()
{
    FunTest();
    system("pause");

    return 0;
}