前序线索二叉树

 

1.遍历前序线索二叉树

void preTraverse(ThrBiTree head){
    ThrBiTree p=head->lChild;
    while(p!=head){
        visit(p->data);
        while(p->lTag==0){
            p=p->lChild;
            visit(p->data);
        }
        while(p->rTag==1&&p->rChild!=head){
            p=p->rChild;
            visit(p->data);
        }
        if(p->lTag==0) p=p->lChild;
        else p=p->rChild;
    }
}

如果当前结点有左孩子，则应该更新p指向左孩子，否则指向右孩子，这与中序遍历线索二叉树不同，中序遍历时，能够确定当前结点的左子树一定被访问过了，直接更新p指向右孩子 

 

2.前序线索化二叉树

void preThreading(ThrBiTree p){
    if(p){
        if(!p->lChild){
            p->lTag=1;
            p->lChild=pre;
        }//这里不应该加else p->lTag=0;//如果在这里加一个else p->lTag=0;就会报错 ，因为当线索化右子树回到双亲时，该双亲已经被线索过了，右指针肯定不空，如果右指针为线索，而又修改rTag=0，则遍历的时候后无法继续 if(!pre->rChild){
            pre->rTag=1;
            pre->rChild=p;
        }//同理，不应该加else pre->rTag=0
        pre=p;
        if(p->lTag==0) preThreading(p->lChild);
        if(p->rTag==0) preThreading(p->rChild);
    }
}

bool preThreadingBiTree(ThrBiTree T,ThrBiTree &head){
    if(!(head=new ThrBiTNode)) return false;
    head->lTag=0;
    head->rTag=1;
    head->rChild=head;
    if(!T) head->lChild=head;
    else{
        pre=head;
        head->lChild=T;
        preThreading(T);
        pre->rChild=head;
        head->rChild=pre;
        head->rTag=1;
    }
    return true;
}

 

3.删除线索二叉树所占空间

void deleteThrBiTree(ThrBiTree &head){
    ThrBiTree p=head->lChild,q;
    while(p!=head){
        q=p;
        while(p->lTag==0){
            p=p->lChild;
            delete q;
            q=p;
        }
        while(p->rTag==1&&p->rChild!=head){
            p=p->rChild;
            delete q;
            q=p;
        }
        q=p;
        p=p->rChild;
        delete q;    
    }
    delete head;
    head=NULL;
}

 

测试：

#include<iostream>
using namespace std;

typedef struct BiTNode{
    int data;
    BiTNode *lChild,*rChild;
    int lTag,rTag;
}ThrBiTNode,*ThrBiTree;

ThrBiTree pre;

void visit(int a){
    cout<<a<<" ";
}bool preAndInCreateBiTree(ThrBiTree &p,int *preOrder,int *inOrder,int length){
    if(length>0){
        if(!(p=new ThrBiTNode)) return false;
        p->data=preOrder[0];
        p->lTag=0;
        p->rTag=0;
        int i;
        for(i=0;i<length&&inOrder[i]!=preOrder[0];++i);
        preAndInCreateBiTree(p->lChild,preOrder+1,inOrder,i);
        preAndInCreateBiTree(p->rChild,preOrder+i+1,inOrder+i+1,length-i-1);    
    }else{
        p=NULL;
    }
    return true;
}

int main(){
    int n,*preOrder,*inOrder;
    
    cout<<"Input the number of nodes : ";
    cin>>n;
    
    preOrder=new int[n];
    inOrder=new int[n];
    cout<<"Input the pre-order sequence : "<<endl;
    for(int i=0;i<n;++i) cin>>preOrder[i];
    cout<<"Input the in-order sequence : "<<endl;
    for(int i=0;i<n;++i) cin>>inOrder[i];
    
    ThrBiTree T;
    ThrBiTree head;
    if(!preAndInCreateBiTree(T,preOrder,inOrder,n)){
        cout<<"Fail to construct this tree"<<endl;
    }else{
        preThreadingBiTree(T,head);
        cout<<"Pre-traverse:"<<endl;
        preTraverse(head);    
    }
    deleteThrBiTree(head);
}