二叉线索树（中序）

#include<iostream>
using namespace std;

    typedef struct student
        {
            int data;
            int ltag=0; //左标志位
            int rtag=0;//右标志位
            student *left;
            student *right;
        }*ThreadTree,tree;

    void init_Thread(ThreadTree &L);
    void insert_node(ThreadTree &L,int e) ;  //用插入节点的办法建立树
    void InThread(ThreadTree &L,ThreadTree &pre); //中序线索化
    void Creat_InThread(ThreadTree L);  //将树线索化
    ThreadTree get_first_node(ThreadTree L);  //得到第一个节点
    ThreadTree get_next_node(ThreadTree L);  //得到后驱节点
    void printlist(ThreadTree L) ; //输出线索树  （中序）
    int main()
        {
            ThreadTree L;
            init_Thread(L);
            int a[8];
            for(int i=0;i<7;i++)
            {
                insert_node(L,i+1);
            }
            Creat_InThread(L);
            printlist(L);
            return 0;
        }

    void init_Thread(ThreadTree &L)
        {
            L=new tree;
            L=NULL;
        }

    void insert_node(ThreadTree &L,int e)   //用插入节点的办法建立树
        {
            if(L==NULL)
            {
                ThreadTree s=new tree;
                s->data=e;
                s->left=NULL;
                s->right=NULL;
                L=s;
                return;
            }

            if(e<L->data)

            {
                insert_node(L->left,e);
            }

            else if(e>L->data)

            {
                insert_node(L->right,e);
            }

            else
            {
                cout<<"插入元素和这棵树有一样的傲"<<endl;
                return ;
            }

        }


       void InThread(ThreadTree &L,ThreadTree &pre) //中序线索化
            {
                if(L!=NULL)
                {
                    InThread(L->left,pre); //递归线索化左子树
                    if(L->left==NULL) //表示其为线索
                        {
                            L->left=pre;
                            L->ltag=1;
                        }
                    if(pre!=NULL&&pre->right==NULL)  //如果前驱节点不为空 并且其右指针不为空
                        {
                            pre->right=L;
                            pre->rtag=1; //表示为线索
                        }
                     pre=L;
                     InThread(L->right,pre); //L->right为pre的后驱//递归处理右子树
                }

            }

        void Creat_InThread(ThreadTree L)  //将树线索化
            {
                if(L!=NULL)
                {
                    ThreadTree pre=NULL;
                    InThread(L,pre);  //对其线索化
                    pre->right=NULL;  // pre为最后一个遍历的节点，其无后驱节点
                }
            }

        ThreadTree get_first_node(ThreadTree L)  //得到第一个节点
            {
                if(L==NULL)
                {
                    return NULL;
                }

                ThreadTree t=L;
                while(t->ltag!=1)
                {
                    t=t->left;
                }
               return t;
            }

        ThreadTree get_next_node(ThreadTree L)  //得到后驱节点
            {
                if(L==NULL)
                {
                    return NULL;
                }

                if(L->rtag==0)//如果其不是线索 则其右子树的最左端节点为其后驱节点
                {
                    return get_first_node(L->right);
                }

                else
                {
                    return L->right;   //否则其右指针就为其后驱节点
                }
            }

        void printlist(ThreadTree L)
            {
                ThreadTree p=get_first_node(L);   //得到第一个节点
                while(p!=NULL)
                {
                    cout<<p->data<<" ";
                    p=get_next_node(p);  //得到其后驱节点
                }
            }