线索二叉树

　　在二叉树2n个链中，总共有n+1是空链。A.J.Perlis 和 C.Thornton一想出种巧妙的方法来利用利用这些空链。即线索二叉树

线索建立规则：

1.如果ptr的左子树ptr->left_child==null,则在中序遍历中，ptr->left_child指向ptr的序列的前驱结点，来替代空链

2.如果ptr的左子树ptr->right_child==null,则在中序遍历中，ptr->right_child指向ptr的序列的后继结点，来替代空链

线索结构说明

template <class T> struct thread_tree_node
{
	T data;
	thread_tree_node<T> *lchild,*rchild;
	bool left_thread,right_thread;
};

其中 left_thread=true 表示lchild指向的是线索否则是左子树，同样right_threads

例如图(a)是一棵中序线索二叉树，它的线索链表如图(b)所示s

 

图a

图b

 

//线索树
template <class T> class thread_tree
{
    public:
        thread_tree();
        ~thread_tree();
        void convert2thread(tree<T> &);
        void travel();
        thread_tree_node<T> *root;


    private:
        thread_tree_node<T> *find_next(thread_tree_node<T> * node);
        thread_tree_node<T> head;
        thread_tree_node<T> * copy_base( tree_node<T> *p);
        
};

//构造函数
template<class T> thread_tree<T>::thread_tree()
{
    head.data=0;
    head.left_thread=head.right_thread=false;
    head.lchild=NULL;
    head.rchild=&head;
    root=&head;
}

//析构函数
template <class T> thread_tree<T> ::~thread_tree()
{
    thread_tree_node<T> *p=find_next(root);
        thread_tree_node<T> *temp=NULL;
    while (p!=root)
    {
        temp=p;
        p=find_next(p);
        delete temp;
    }
    
cout<<"destruct over"<<endl;

}

//将一棵树转化为线索树
template <class T> void thread_tree<T>::convert2thread(tree<T> &obj)
{
    stack_list<thread_tree_node<T>* > stack;

    tree_node<T> *tree_root=obj.get_root();
    
    
    //空树
    if(!tree_root)
        return;
    // 够着基本树结构

    head.lchild=copy_base(tree_root);

    thread_tree_node<T> *p=head.lchild;
    thread_tree_node<T> * previous=NULL;

    //对root中序遍历，并建立线索树节点
    while (1)
    {
        //左节点进栈
        while (p)
        {
            stack.push(p);
            p=p->lchild;
        }
                
        //栈空结束
        if(stack.isEmpty())
            break;    

        //出栈,并设置线索
        p=stack.Top();
        //cout<<p->data<<" left:"<<p->left_thread<<" right:"<<p->right_thread<<endl;
        stack.pop();
    
        //前驱线索
        if(p->left_thread)
        {
            if (previous==NULL)
                p->lchild=root;    
            else
                p->lchild=previous;
        }
        
        //后继线索
        if(p->right_thread)
        {
            if (stack.isEmpty())
                p->rchild=root;
            else
                p->rchild=stack.Top();
        }
    
        previous=p;

        if (p->right_thread)
            p=NULL;
        else
            p=p->rchild;
        
    }
    cout<<"convert to thread tree successful"<<endl;
}

//复制基本的树结构
template <class T> thread_tree_node<T> * thread_tree<T>::copy_base(tree_node<T> *p)
{
    if (p)
    {
        thread_tree_node<T> *thread_p =new thread_tree_node<T>;
        if (!thread_p)
        {
            cout<<"new thread tree node error"<<endl;
        }
        else
        {
            thread_p->data=p->value;
            if (p->lchild)
                thread_p->left_thread=false;
            else
                thread_p->left_thread=true;

            if (p->rchild)
                thread_p->right_thread=false;
            else
                thread_p->right_thread=true;

            thread_p->lchild=copy_base(p->lchild);
            thread_p->rchild=copy_base(p->rchild);
        }
        return thread_p;
    }
    else
    {
        return NULL;
    }
} 


//线索遍历，中序
template<typename T> void thread_tree<T>::travel()
{
    thread_tree_node<T> *temp=root;
    while(1)
    {
        temp=find_next(temp);
        if (temp==root)
            break;
        cout<<temp->data;
    }

    cout<<"\ninorder travel over"<<endl;

}

//寻找后继节点
template<class T>  thread_tree_node<T>* thread_tree<T>::find_next(thread_tree_node<T> * node)
{
    //线索
    if (node->right_thread)
    {
        return node->rchild;
    }
    else
    {
        thread_tree_node<T> *temp=node->rchild;
        while (!temp->left_thread)
        {
            temp=temp->lchild;
        }
        return temp;
    }

}