二叉树线索化及遍历-优快云博客

本文链接：https://blog.youkuaiyun.com/ChaseRaod/article/details/78242117

#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.youkuaiyun.com/my_heart_/article/details/52087948
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 _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;
}

这里写图片描述