数据结构——线索化二叉树

最新推荐文章于 2022-10-02 14:42:13 发布

雪沫沫

最新推荐文章于 2022-10-02 14:42:13 发布

阅读量170

点赞数

分类专栏： C++学习数据结构文章标签：数据结构二叉树

本文链接：https://blog.csdn.net/gaoruxue918/article/details/72287107

版权

数据结构同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

C++学习

16 篇文章 0 订阅

订阅专栏

#include <iostream>
using namespace std;

enum PiontFlag{LINK,THREAD};

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

    T _data;
    BinaryTreeNode<T>* _pLeft;
    BinaryTreeNode<T>* _pRight;
    PiontFlag _leftThread;
    PiontFlag _rightThread;
};

template<class T>
class BinaryTreeThd
{
    typedef BinaryTreeNode<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()
    {
        cout<<"PreOrder()"<<endl;
        _PreOrder(_pRoot);
    }
    void InOrder()
    {
        cout<<"InOrder()"<<endl;
        _InOrder(_pRoot);
    }
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)//注意prev应传其引用否则带不回前值
    {
        if(pRoot)
        {
            //线索化当前节点的左指针域
            if(NULL == pRoot->_pLeft )
            {
                pRoot->_pLeft = prev;
                pRoot->_leftThread = THREAD;
            }
            //线索化前一个节点的右指针域
            if(prev && NULL == prev->_pRight )
            {
                prev->_pRight = pRoot;
                prev->_rightThread = THREAD;
            }
            prev = pRoot;
            if(LINK == pRoot->_leftThread )
                _PreThreading(pRoot->_pLeft ,prev);
            if(LINK == pRoot->_rightThread )
                _PreThreading(pRoot->_pRight ,prev);
        }
    }
    void _InThreading(Node* pRoot,Node*& prev)
    {
        if(pRoot)
        {
            if(LINK == pRoot->_leftThread )
                _InThreading(pRoot->_pLeft ,prev);

            //线索化当前节点的左指针域
            if(NULL == pRoot->_pLeft )
            {
                pRoot->_pLeft = prev;
                pRoot->_leftThread = THREAD;
            }

            //线索化前一个节点的右指针域
            if(prev && NULL == prev->_pRight )
            {
                prev->_pRight = pRoot;
                prev->_rightThread = THREAD;
            }
            prev = pRoot;
            if(LINK == pRoot->_rightThread )
                _InThreading(pRoot->_pRight ,prev);
        }
    }
    void _PostThreading(Node* pRoot,Node*& prev)
    {
        if(pRoot)
        {
            if(LINK == pRoot->_leftThread )
                _PostThreading(pRoot->_pLeft ,prev);
            if(LINK == pRoot->_rightThread )
                _PostThreading(pRoot->_pRight ,prev);
            //线索化当前节点的左指针域
            if(NULL == pRoot->_pLeft )
            {
                pRoot->_pLeft = prev;
                pRoot->_leftThread = THREAD;
            }
            //线索化前一个节点的右指针域
            if(prev && NULL == prev->_pRight )
            {
                prev->_pRight = pRoot;
                prev->_rightThread = THREAD;
            }
            prev = pRoot;
        }
    }
    void _PreOrder(Node* pRoot)
    {
        if(pRoot)
        {
            Node* pCur = pRoot;
            while(pCur)
            {
                while(LINK == pCur->_leftThread )
                {
                    cout<<pCur->_data <<" ";
                    pCur = pCur->_pLeft ;
                }
                cout<<pCur->_data <<" ";
                pCur = pCur->_pRight ;
                //while(THREAD == pCur->_rightThread )
                //{
                //  pCur = pCur->_pRight ;
                //  cout<<pCur->_data <<" ";
                //}
                //if(LINK == pCur->_leftThread )
                //  pCur = pCur->_pLeft ;
                //else
                //  pCur = pCur->_pRight ;
            }
        }
    }
    void _InOrder(Node* pRoot)
    {
        Node* pCur = pRoot;
        while(pCur)
        {
            while(pCur->_leftThread == LINK)
                pCur = pCur->_pLeft ;
            cout<<pCur->_data <<" ";
            while(THREAD == pCur->_rightThread )
            {
                pCur = pCur->_pRight ;
                cout<<pCur->_data <<" ";
            }
            pCur = pCur->_pRight ;
        }
    }
private:
    Node* _pRoot;
};