树和二叉树（四）-线索化二叉树

线索二叉树的主要操作就是建立线索二叉书和遍历线索二叉树。
测试代码
1.前序线索化

void _PrevOrderThreading(Node* cur, Node* &prev)
    {
        if (cur == NULL)
        {
            return;
        }
        if (cur->_left == NULL)
        {
            cur->_left = prev;
            cur->_leftType = THREAD;
        }
        if (prev&&prev->_right == NULL)
        {
            prev->_right = cur;
            prev->_rightType = THREAD;
        }
        prev = cur;
        if (cur->_leftType == LINK)
        {
            _PrevOrderThreading(cur->_left, prev);
        }
        if (cur->_rightType == LINK)
        {
            _PrevOrderThreading(cur->_right, prev);
        }
    }

2.中序线索化

    void _InOrderThreading(Node* cur, Node* & prev)//中序线索化
    {
        if (cur == NULL)
            return;
        _InOrderThreading(cur->_left, prev);
        if (cur->_left == NULL)
        {
            cur->_left = prev;
            cur->_leftType = THREAD;
        }
        if (prev&&prev->_right == NULL)
        {
            prev->_right = cur;
            prev->_rightType = THREAD;
        }
        prev = cur;
        _InOrderThreading(cur->_right, prev);
    }

#include<iostream>
#include<assert.h>
#include <stack>
using namespace std;

enum PointerType
{
    THREAD,
    LINK,
};
template<class T>
struct  BinaryTreeNode
{
    T data;
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
    PointerType _leftType;
    PointerType _rightType;
    BinaryTreeNode(const T& x)
        :_left(NULL)
        , _right(NULL)
        , data(x)
        , _leftType(LINK)
        , _rightType(LINK)
    {}
};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree() //无参构造函数
        :_root(NULL)
    {}
    BinaryTree(T* a, size_t n, const T& invalid) //构造函数
    {
        size_t index = 0;
        _root = CreateTree(a, n, invalid, index);
    }
    void PrevOrderThreading() //前序线索化
    {
        Node *prev = NULL;
        _PrevOrderThreading(_root, prev);
    }
    void PrevOrderThd() //线索化后前序遍历-非递归
    {
        if (_root == NULL)
        {
            return;
        }
        Node* cur = _root;
        while (cur)
        {
            while (cur->_leftType == LINK)
            {
                cout << cur->data << " ";
                cur = cur->_left;
            }
            cout << cur->data << " ";
            cur = cur->_right;
        }
        cout << endl;
    }
    void _PrevOrderThreading(Node* cur, Node* &prev)
    {
        if (cur == NULL)
        {
            return;
        }
        if (cur->_left == NULL)
        {
            cur->_left = prev;
            cur->_leftType = THREAD;
        }
        if (prev&&prev->_right == NULL)
        {
            prev->_right = cur;
            prev->_rightType = THREAD;
        }
        prev = cur;
        if (cur->_leftType == LINK)
        {
            _PrevOrderThreading(cur->_left, prev);
        }
        if (cur->_rightType == LINK)
        {
            _PrevOrderThreading(cur->_right, prev);
        }
    }

    void InOrderThreading() //中序线索化
    {
        Node* prev = NULL;
        _InOrderThreading(_root, prev);
    }
    void _InOrderThreading(Node* cur, Node* & prev)//中序线索化
    {
        if (cur == NULL)
            return;
        _InOrderThreading(cur->_left, prev);
        if (cur->_left == NULL)
        {
            cur->_left = prev;
            cur->_leftType = THREAD;
        }
        if (prev&&prev->_right == NULL)
        {
            prev->_right = cur;
            prev->_rightType = THREAD;
        }
        prev = cur;
        _InOrderThreading(cur->_right, prev);
    }
    void InOrderTraverse_Thr()//线索化后中序遍历-非递归
    { 
        Node* root = _root;
        while (root)
        { 
            while (root->_leftType == LINK) //由根结点一直找到二叉树的最左结点 
                root = root->_left;
            cout << root->data << " ";
            while (root->_rightType == THREAD&&root->_right != NULL) //root->_right是线索(后继)，且不是遍历的最后一个结点 
            {
                root = root->_right;
                cout << root->data << " "; //访问后继结点 
            }
            root = root->_right; // 若root->_right不是线索(是右孩子)，root指向右孩子，返回循环
        }              // 找这棵子树中序遍历的第1个结点 
    }

protected:
    Node* CreateTree(T* a, size_t n, const T& invalid, size_t& index) //创建子树
    {
        Node* root = NULL;
        if (index < n&&a[index] != invalid)
        {
            root = new Node(a[index]);
            root->_left = CreateTree(a, n, invalid, ++index);
            root->_right = CreateTree(a, n, invalid, ++index);
        }
        return root;
    }

protected:
    Node* _root;
};
void test() //测试函数
{
    //int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
    int array[13] = { 1, 2, 3, '#','#', 4, '#', '#', 5, 6, '#', '#', '#' };
    BinaryTree<int> T1(array, sizeof(array) / sizeof(array[0]), '#');
    //T1.PrevOrderThreading();
    //T1.PrevOrderThd();
    //T1.InOrderThreading();
    //T1.InOrderTraverse_Thr();
}
int main()
{
    test();
    system("pause");
    return 0;
}