二叉树的线索化及其迭代器

1.不借用栈或者队列来实现遍历的非递归，还有一种方法是线索化。
2.为了实现迭代器，面向对象。

线索化也分为前中后序的线索化。
线索化有前驱和后继。
一棵树只能被线索化成一种方式。
树和图重要的区别是有没有环，树没有环，图可以有环。



当出现上面的问题时，是因为最后一个结点没有线索化，导致程序崩了。

访问中序线索化后的二叉树：



现在我们就开始前序的线索化，注意二叉树同时只能被一种顺序线索化，不能同时线索化成多种顺序的模式。
前序线索化


前序线索化的遍历
前序线索化的遍历是比较简单的，只需要开始访问后继是LINK类型的左结点，如果访问到最左结点就直接访问右结点，因为右结点都是已经线索化过的结点，可以直接访问到最后。

接下来就是二叉树线索化的迭代器转化。
首先我们可以先造一个中序迭代器，先不考虑其他的东西。

其次，我们按照同样的道理可以造一个前序的迭代器，这些迭代器可以在遍历的时候方便我们遍历，因为迭代器会提供指针来遍历二叉树，而且这个指针可以通过++、–自动的跳到下一个结点可以让我们在实例化的时候不考虑其底层实现是什么类型。

接着为了代码的利用率提高，可以试着将前序迭代器与中序迭代器的操作符重载相同的复用起来，实现不同的操作符重载可以使用虚函数的重写达到调用相应迭代器从而可以很好的实现各种线索化下的遍历访问。

这个是很困扰的我的问题，关于继承虚函数的重写，总是跳出有关于子类和父类构造函数的问题。
当子类继承父类的成员变量的时候，就需要在子类构造函数里用父类的类名构造函数。

寻觅良久，终得答案。

~在这里将所有代码奉上~

这是线索化的代码

#pragma oncenamespace Thread//线索化的命名空间{    enum PointerTag //区分线索化和孩子    {        THREAD,//线索化        LINK   //子树    };    template<class T>    struct BinaryTreeNode    {        T _data;        BinaryTreeNode<T>* _left;        BinaryTreeNode<T>* _right;        PointerTag _leftTag;//标识左指针是否是孩子或者线索化指针        PointerTag _rightTag;//标识右指针是否是孩或者线索化指针        BinaryTreeNode(const T& x)            : _data(x)            , _left(NULL)            , _right(NULL)            , _leftTag(LINK)            , _rightTag(LINK) //构建过程不管线索化的        {}    };    //基类迭代器    template<class T>    struct BinaryTreeIterator    {        typedef BinaryTreeNode<T> Node;        typedef BinaryTreeIterator<T> Self;        Node*_node;        BinaryTreeIterator(Node*node)            :_node(node)        {}        bool operator==(const Self&s)        {            return s._node == _node;        }        virtual bool operator!=(const Self&s)        {            return _node != s._node;        }        T* operator->()        {            return &_node->_data;        }        T& operator*()        {            return _node->_data;        }        virtual Self& operator++() = 0;    };    //中序迭代器    template<class T>    struct __BinaryTreeInIterator : public BinaryTreeIterator<T>        //智能指针为了实现RAII自动释放    {                                   //迭代器指针为了天然循环遍历        typedef BinaryTreeNode<T> Node;        typedef __BinaryTreeInIterator<T> Self;        //不需要再定义_node，因为中序迭代器继承基类迭代器的_node            //Node* _node;//迭代器中提供的指向结点的指针        __BinaryTreeInIterator(Node* node)            :BinaryTreeIterator(node)//调用基类构造函数        {}        //bool operator==(const Self&s)//不使用基类迭代器的中序迭代器        //{        //  return s._node == _node;        //}        //virtual bool operator!=(const Self&s)        //{        //  return _node != s._node;        //}        //T* operator->()        //{        //  return &_node->_data;        //}        //T& operator*()        //{        //  return _node->_data;        //}        Self& operator++()        {            if (_node->_rightTag == THREAD)            {                _node = _node->_right;            }            else            {                Node*right = _node->_right;                while (right->_leftTag != THREAD)                {                    right = right->_left;                }                _node = right;            }            return *this;        }    };    //前序迭代器    template<class T>    struct __BinaryTreePrevIterator:public BinaryTreeIterator<T> //继承父类迭代器    {        typedef BinaryTreeNode<T> Node;        typedef __BinaryTreePrevIterator<T> Self;        __BinaryTreePrevIterator(Node*node)            :BinaryTreeIterator(node)        {}        //bool operator==(const Self&s)//不使用基类迭代器的前序迭代器        //{        //  return s._node == _node;        //}        //virtual bool operator!=(const Self&s)        //{        //  return _node != s._node;        //}        //T* operator->()        //{        //  return &_node->_data;        //}        //T& operator*()        //{        //  return _node->_data;        //}        Self& operator++()//前序迭代器操作符重载        {            if (_node->_leftTag == LINK)            {                _node = _node->_left;            }            else            {                    _node = _node->_right;            }            return*this;        }    };    //二叉树线索化    template<class T>    class BinaryTree    {        typedef BinaryTreeNode<T> Node;        typedef __BinaryTreeInIterator<T> InIterator;        typedef __BinaryTreePrevIterator<T> PrevIterator;    public:        typedef BinaryTreeIterator<T> Iterator;        //注意：在不使用基类迭代器进行封装的时候需要可以访问到前中序的迭代器。        //typedef __BinaryTreeInIterator<T> InIterator;        //typedef __BinaryTreePrevIterator<T> PrevIterator;        BinaryTree()            :_root(NULL)        {}        BinaryTree(T* a, size_t n, const T& invalid)        {            size_t index = 0;            _root = _CreateTree(a, n, invalid, index);        }        //中序迭代器InBegin()        InIterator InBegin()        {            Node*left = _root;            while (left && left->_leftTag == LINK)//空树可以走迭代器            {                left = left->_left;            }            return left;        }        //中序迭代器InEnd()        InIterator InEnd()        {            return NULL;        }        void InOrderThreading()//中序线索化        {            Node*prev = NULL;            _InOrderThreading(_root, prev);            //线索化最后一个结点            if (_root)            {                Node* right = _root->_right;                while (right->_right)                {                    right = right->_right;                }                right->_rightTag = THREAD;            }        }        void _InOrderThreading(Node* cur, Node*& prev)//这里需要用引用，起到真正改变prev的作用        {            if (cur == NULL) // cur表示当前结点                return;            _InOrderThreading(cur->_left, prev);//先走左子树            if (cur->_left == NULL)            {                cur->_left = prev;                cur->_leftTag = THREAD;            }            if (prev && prev->_right == NULL)            {                prev->_right = cur;                prev->_rightTag = THREAD;            }            prev = cur;            _InOrderThreading(cur->_right, prev);//最后走右子树        }        void InOrderThread()//访问中序线索化的树        {            Node*cur = _root;            while (cur)            {                while (cur->_leftTag == LINK)//遍历左结点                {                     cur = cur->_left;                }                cout << cur->_data << " ";                //if (cur->_rightTag == LINK) //一般方法                //{                //  cur = cur->_right;                // }                //else                //{                //  while (cur->_rightTag == THREAD)                //  {                //      cur = cur->_right;                //      cout << cur->_data << " ";                //      if (cur->_right == NULL)                //          break;                //  }                //  cur = cur->_right;                //}                //优化方法                while(cur->_rightTag == THREAD)//按照线索化走到最后一个结点                {                    if (cur->_right == NULL)                        break;                    cur = cur->_right;                    cout << cur->_data << " ";                }                cur = cur->_right;            }            cout << endl;        }        //前序迭代器PrevBegin()        PrevIterator PrevBegin()        {            return _root;        }        //前序迭代器PrevEnd()        PrevIterator PrevEnd()        {            return NULL;        }        void PrevOrderThreading()//前序线索化        {            Node*prev = NULL;            _PrevOrderThreading(_root, prev);            if (_root)            {                Node* right = _root->_right;                while (right->_rightTag == THREAD)                {                    right = right->_right;                }                right->_rightTag = THREAD;            }        }        void _PrevOrderThreading(Node*cur, Node*&prev)//必须要是引用，不然上一层改变下一层看不到        {            if (cur == NULL)                return;            if (cur->_left == NULL)            {                cur->_left = prev;                cur->_leftTag = THREAD;            }            if (prev && prev->_right == NULL)            {                prev->_rightTag = THREAD;                prev->_right = cur;            }            prev = cur;            if (cur->_leftTag == LINK)            {                _PrevOrderThreading(cur->_left, prev);            }            if (cur->_rightTag == LINK)            {                _PrevOrderThreading(cur->_right, prev);            }        }        void PrevOrderThread()//前序线索化的访问        {            Node*cur = _root;            while (cur)            {                while (cur->_leftTag == LINK)                {                    cout << cur->_data << " ";                    cur = cur->_left;                }                cout << cur->_data << " ";                cur = cur->_right;            }        }        //在递归里，index变化会影响，所以要加引用        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;        }        //void PostOrderThreading();//后序    private:        Node*_root;    };

测试代码如下：

    //测试代码    void TestBinaryTree()    {        int a2[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };        //int a2[] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };        BinaryTree<int> t(a2, sizeof(a2) / sizeof(a2[0]), '#');        //中序        //t.InOrderThreading();        //t.InOrderThread();  // 中序线索化遍历函数        //前序        t.PrevOrderThreading();        //t.PrevOrderThread();   // 前序线索化遍历函数        //中序迭代器(不使用基类迭代器）遍历        //BinaryTree<int>::InIterator it1 = t.InBegin();        //while (it1 != t.InEnd())        //{        //  cout << *it1 << " ";        //  ++it1;        //}        //cout << endl;        //前序迭代器（不使用基类迭代器）遍历        //BinaryTree<int>::PrevIterator it2 = t.PrevBegin();        //while (it2 != t.PrevEnd())        //{        //  cout << *it2 << " ";        //  ++it2;        //}        //cout << endl;        //使用基类迭代器遍历中序线索化后的二叉树        //BinaryTree<int>::Iterator& it3 = t.InBegin();//&——纯虚函数需要加&来访问到子类的虚函数重写        //while (it3 != t.InEnd())        //{        //  cout << *it3 << " ";        //  ++it3;        //}        //cout << endl;        //使用基类迭代器遍历前序线索化后的二叉树        BinaryTree<int>::Iterator& it4 = t.PrevBegin();//&——纯虚函数需要加&来访问到子类的虚函数重写        while (it4 != t.PrevEnd())        {            cout << *it4 << " ";            ++it4;        }        cout << endl;    }}