节点：
enum LinkType
{
                 THREAD,
                 LINK
};

template
struct ThredBinaryNode
{
                 ThredBinaryNode *_left;
                 ThredBinaryNode *_right;
                 LinkType _left_tag;
                 LinkType _right_tag;

                 T _data;
                ThredBinaryNode( T data ) :_data(data), _left( NULL), _right(NULL ), _left_tag(LINK), _right_tag(LINK)
                {};
};
线索化二叉树为：
template
class BinaryTreeThred
{
                 typedef ThredBinaryNode  Node;
public:
                BinaryTreeThred( const T * a, size_t size, const T & valiue)
                {
                                 size_t index = 0;
                                _root = _CreatTree( a, size , index, valiue);
                }
private:

              Node *_root;

};

构造函数：
                 Node*_CreatTree(const T* a, size_t size, size_t &index, const T &valiue)
                {
                                 Node *root = NULL ;
                                 if (index < size&& a[index ] != valiue)
                                {
                                                root = new Node (a[index]);
                                                root->_left = _CreatTree(a, size , ++index, valiue);
                                                root->_right = _CreatTree(a, size , ++index, valiue);
                                }
                                 return root;
                }

中序线索化递归：

                 void _InThred(Node *cur, Node* & prev)//递归线索化
                {
                                 if (cur != NULL)
                                {

                                                _InThred( cur->_left, prev );
                                                 if (cur ->_left == NULL)
                                                {
                                                                 cur->_left_tag = THREAD ;
                                                                 cur->_left = prev ;
                                                }
                                                 if (prev != NULL&& prev->_right==NULL )
                                                {
                                                                 prev->_right_tag = THREAD ;
                                                                 prev->_right = cur ;
                                                }
                                                 prev = cur ;
                                                _InThred( cur->_right, prev );
                                }


                };

中序线索非递归：
                 void InThred_Nor()//非递归
                {
                                 stack s;
                                 Node *prev = NULL ;
                                 Node *cur = _root;
                                 while (cur||!s.empty())
                                {
                                                 while (cur)
                                                {
                                                                s.push(cur);
                                                                cur = cur->_left;
                                                };
                                                 Node *tmp = s.top();
                                                s.pop();
                                                 if (tmp->_left == NULL )
                                                {
                                                                tmp->_left = prev;
                                                                tmp->_left_tag = THREAD;
                                                }
                                                prev = tmp;
                                                 if (prev->_right == NULL &&!s.empty())
                                                {
                                                                tmp->_right = s.top();
                                                                tmp->_right_tag = THREAD;
                                                }
                                                 else
                                                {
                                                                cur = tmp->_right;
                                                }
                                }
                }



前序线化非递归：
void BinaryTreeThred ::PreThread() //前序线索化非递归
{
                 Node *pre = NULL ;
                 Node*cur = _root;
                 stack s;
                s.push(cur);
                 while (cur||!s.empty())
                {
                                 Node *tmp = NULL ;
                                 if (!s.empty())
                                {
                                                tmp = s.top();
                                }
                                 else
                                {
                                                 return;
                                }


                                s.pop();
                                 if (tmp->_right)
                                {
                                                s.push(tmp->_right);
                                }

                                 if (tmp->_left)
                                {
                                                s.push(tmp->_left);
                                }
                                 else//tmp->left==null
                                {
                                                tmp->_left_tag = THREAD;
                                                tmp->_left=pre;
                                }              
                                 if (pre != NULL &&pre->_right == NULL)
                                {
                                                pre->_right_tag = THREAD;
                                                pre->_right = tmp;
                                }
                                pre = tmp;
                }
}

后序列线索话非递归：

void BinaryTreeThred ::PostThread() //后续
{
                 Node *cur = _root;
                 stack s;
                 Node *prev = NULL ;
                 while (cur || !s.empty())
                {
                                 while (cur)
                                {
                                                s.push(cur);
                                                cur = cur->_left;//3
                                }
                                 Node *tmp = s.top();
                                 if (tmp->_right == NULL || tmp->_right == prev)
                                {
                                                 if (tmp->_left == NULL )
                                                {
                                                                tmp->_left_tag = THREAD;
                                                                tmp->_left = prev;
                                                }
                                                 if (prev != NULL &&prev->_right == NULL)
                                                {
                                                                prev->_right_tag = THREAD;
                                                                prev->_right = tmp;
                                                }
                                                s.pop();
                                                prev = tmp;
                                }
                                 else
                                {
                                                cur = tmp->_right;
                                }
                }

}

创新互联建站专注于澧县企业网站建设,自适应网站建设,商城网站定制开发。澧县网站建设公司,为澧县等地区提供建站服务。全流程定制网站设计，专业设计，全程项目跟踪，创新互联建站专业和态度为您提供的服务

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

当前标题：数据结构之二叉树（前序中序后续线索话非递归方式）-创新互联
转载来于：http://myzitong.com/article/dhshci.html