线索化二叉树

来源：互联网发布：海绵城市知乎编辑：程序博客网时间：2024/06/05 03:42

#include<iostream>using namespace std;#include<assert.h>enum PointTag{    LINK, //子问题    THREAD//线索化};//线索化二叉树的节点template<class T>class ThreadTreeNode{public:    T _data;    ThreadTreeNode<T>* _left;    ThreadTreeNode<T>* _right;    PointTag _leftTag;    PointTag _rightTag;    ThreadTreeNode(const T& data)        :_data(data)        , _left(NULL)        , _right(NULL)        , _leftTag(LINK)        , _rightTag(LINK)    {}};//中序线索化的迭代器template<class T,class Ref,class Ptr>class InOrderTreadIterator{    typedef ThreadTreeNode<T> Node;    typedef InOrderTreadIterator<T,T&,T*> Self;public:    InOrderTreadIterator()    {}    InOrderTreadIterator(Node* root)        :_root(root)    {}    Self& operator++()    {        assert(_root);        if (_root->_rightTag == THREAD)//如果是最后一个节点呢？            _root = _root->_right;        else        {            Node* cur = _root->_right;            while (cur && cur->_leftTag == LINK)                cur = cur->_left;            _root = cur;        }        return *this;    }    Self& operator--()    {        assert(_root);        if (_root->_leftTag == THREAD)            return _root->_left;        else        {            Node* cur = _root->_left;            while (cur && cur->_right == LINK)                cur = cur->_right;        }        return cur;    }    Ref operator*()    {        return _root->_data;    }    Ptr operator->()    {        return &(_root->_data);    }    Self operator++(int)//后置++    {        Self tmp(*this);        ++tmp;        return *this;    }    Self operator--(int)    {        Self tmp(*this);        --tmp;        return *this;    }    bool operator != (const Self& s)const    {        return _root != s._root;    }    bool operator == (const Self& s)const    {        return _root == s._root;    }protected:    Node* _root;};//线索化二叉树template<class T>class InorderThreadTree{public:    typedef ThreadTreeNode<T> Node;    typedef InOrderTreadIterator<T,T&,T*> Iterator;    typedef InOrderTreadIterator<const T,const T&,const T*> ConstIterator;    InorderThreadTree()        :_root(NULL)    {}    InorderThreadTree(T* _a, size_t n, const T& _invalid)    {        size_t index = 0;        _root = _CreateTree(_a, n, _invalid, index);    }    //中序线索化    void InOrderTreading()    {        Node* prev = NULL;        _InOrderTreading(_root, prev);        //线索化最后一个节点        if (_root)        {            Node* right = _root->_right;            while (right->_right)            {                right = right->_right;            }            right->_rightTag = THREAD;        }    }    //中序线索化遍历二叉树    void InOrderThd()    {        Node* cur = _root;        while (cur)        {            while (cur->_leftTag == LINK)            {                cur = cur->_left;            }            cout << cur->_data << " ";            while (cur && cur->_rightTag == THREAD)            {                cur = cur->_right;                if (cur)//最后一个节点为NULL                    cout << cur->_data << " ";            }            if (cur)//子问题                cur = cur->_right;        }        cout << endl;    }    Iterator Begin()    {        Node* cur = _root;        while (cur->_leftTag == LINK)        {            cur = cur->_left;        }        return cur;//单参数构造函数隐式转换    }    Iterator End()    {        return NULL;    }protected:    void _InOrderTreading(Node* cur, Node*& prev)    {        {            if (cur == NULL)            return;            //线索化左子树            if (cur->_leftTag == LINK)            _InOrderTreading(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;            //线索化右子树            if (cur->_rightTag== LINK)            _InOrderTreading(cur->_right, prev);        }    }    Node* _CreateTree(const 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;    }    Node* _root;};//前序线索化的迭代器template<class T,class Ref,class Ptr>class PrevIterator{public:    typedef ThreadTreeNode<T> Node;    typedef PrevIterator<T, T&, T*> Self;    PrevIterator()    {}    PrevIterator(Node* root)        :_root(root)    {}    Ref operator*()    {        return _root->_data;    }    Ptr operator->()    {        return &(_root->_data);    }    bool operator == (const Self& s)const    {        return _root == s._root;    }    bool operator != (const Self& s) const    {        return _root != s._root;    }    //前置++    Self& operator++()    {        if (_root->_leftTag == LINK)            _root = _root->_left;        else        {            _root = _root->_right;        }        return *this;    }protected:    Node* _root;};template<class T>class PreOrderThread{public:    typedef ThreadTreeNode<T> Node;    typedef PrevIterator<T, T&, T*> Iterator;    //前序线索化二叉树    PreOrderThread()    {}    PreOrderThread(const T* a, size_t n, const T& invalid)    {        size_t index = 0;        _root = _CreateTree(a, n, invalid, index);    }    void PrevThreding()    {        Node* prev = NULL;        _PrevThreading(_root, prev);        //线索化最后一个节点        if (prev)            prev->_rightTag = THREAD;    }    //前序线索化遍历    void PreOrerThd()    {        Node* cur = _root;        while (cur)        {            while (cur->_leftTag == LINK)            {                cout << cur->_data << " ";                cur = cur->_left;            }            cout << cur->_data << " ";//最左节点            cur = cur->_right;        }        cout << endl;    }    Iterator Begin()    {        return _root;    }    Iterator End()    {        return NULL;    }protected:    Node* _CreateTree(const 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 _PrevThreading(Node* root,Node*& prev)    {        Node* cur = root;        if (cur == NULL)            return;        //线索化根节点        if (cur->_left == NULL)        {            cur->_left = prev;            cur->_leftTag = THREAD;        }        if (prev && prev->_right == NULL)        {            prev->_right = cur;            prev->_rightTag = THREAD;        }        prev = cur;//将当前节点置为前一个节点        //线索化左子树        if (cur->_leftTag == LINK)            _PrevThreading(cur->_left, prev);        //线索化右子树        if (cur->_rightTag == LINK)            _PrevThreading(cur->_right, prev);    }    Node* _root;};//后续线索化二叉树template<class T>class PostOrderThread{public:    typedef ThreadTreeNode<T> Node;    PostOrderThread()    {}    PostOrderThread(const T* a, size_t n, const T& invalid)    {        size_t index = 0;        _root = _CreateTree(a, n, invalid, index);    }    //后续线索化    void PostThreading()    {        Node* prev = NULL;        _PostThreading(_root, prev);    }    //后续线索化的遍历    //贴链接 http://blog.csdn.net/my_heart_/article/details/52087948protected:    Node* _CreateTree(const 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 _PostThreading(Node* root, Node*& prev)    {        if (root == NULL)            return;        //线索化左子树        if (root->_leftTag == LINK)            _PostThreading(root->_left, prev);        if (root->_right == LINK)            _PostThreading(root->_right);        if (root->_left == NULL)        {            root->_leftTag = THREAD;            root->_left = prev;        }        if (prev && prev->_right == NULL)        {            prev->_right = cur;            prev->_rightTag = THREAD;        }        prev = cur;    }    Node* _root;};void TestInOrder(){    int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };    size_t size = sizeof(array) / sizeof(array[0]);    InorderThreadTree<int> th(array, size, '#');    th.InOrderTreading();    th.InOrderThd();    InorderThreadTree<int>::Iterator it = th.Begin();    while (it != th.End())    {        cout << *it << " ";        ++it;    }    cout << endl;}void TestPreOrder(){    int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };    size_t size = sizeof(array) / sizeof(array[0]);    PreOrderThread<int>th(array, size, '#');    th.PrevThreding();    th.PreOrerThd();    PreOrderThread<int>::Iterator it = th.Begin();    while (it != th.End())    {        cout << *it << " ";        ++it;    }    cout << endl;}

后续线索化

#include"thread.h"int main(){    //TestInOrder();    TestPreOrder();    system("pause");    return 0;}

这里写图片描述

阅读全文

0 0