問題描述

在二叉樹中查詢值為x的節點，試編寫演算法列印值為x的節點的所有祖先節點，假設值為x的節點不多於一個

演算法思想

因為僅僅只是列印祖先節點，可以考慮使用非遞迴後序遍歷的方式來實現。
在非遞迴後序遍歷的方式中，保留在棧中的所有元素（除棧頂外）必然是棧頂的祖先節點，因此只要找到x節點，然後將棧中所有節點出棧便可。

演算法描述

void AncestorX(BiTNode* T,ElemType x){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;
    BiTNode* r=NULL;

    while
 
(p||IsEmptyStack(&S)){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=GetTop(&S);
            if(p->rchild!=NULL&&p->rchild!=r){
                p=p->rchild;
                Push(&S,p);
                p=p->lchild;
            }else
 
{
                p=Pop(&S);
                if(p->data==x){
                    while(IsEmptyStack(&S)!=0){
                        p=Pop(&S);
                        printf("%c",p->data);
                    }
                }
                r=p;
                p=NULL;
            }
        }
    }   
}
 

具體程式碼見附件。

附件

//AB#DG###CE##F##
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef char ElemType;
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode,*BiTree;

typedef struct SqStack{
    BiTNode* data[MaxSize];
    int top;
}SqStack;

void InitStack(SqStack*);
void Push(SqStack*,BiTNode*);
BiTNode* Pop(SqStack*);
BiTNode* GetTop(SqStack*);
int IsEmptyStack(SqStack*);

BiTree CreateBiTree(BiTNode*);
void AncestorX(BiTNode*,ElemType);

void Judge(BiTNode*);
void PreOrder(BiTNode*);
void InOrder(BiTNode*);

//-------------------------------------------

int main(int argc,char* argv[]){
    BiTNode* T=(BiTNode*)malloc(sizeof(BiTNode));
    T=CreateBiTree(T);

    Judge(T);

    AncestorX(T,'F');
    printf("\n");

    return -1;
}

//-------------------------------------------

BiTree CreateBiTree(BiTNode* T){
    ElemType x;
    scanf("%c",&x);
    if(x=='#'){
        return NULL;
    }
    T=(BiTNode*)malloc(sizeof(BiTNode));
    T->data=x;
    T->lchild=CreateBiTree(T->lchild);
    T->rchild=CreateBiTree(T->rchild);
    return T;
}

void AncestorX(BiTNode* T,ElemType x){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;
    BiTNode* r=NULL;

    while(p||IsEmptyStack(&S)){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=GetTop(&S);
            if(p->rchild!=NULL&&p->rchild!=r){
                p=p->rchild;
                Push(&S,p);
                p=p->lchild;
            }else{
                p=Pop(&S);
                if(p->data==x){
                    while(IsEmptyStack(&S)!=0){
                        p=Pop(&S);
                        printf("%c",p->data);
                    }
                }
                r=p;
                p=NULL;
            }
        }
    }   
}

//-------------------------------------------

void Judge(BiTNode* T){
    printf("---------------\n");
    PreOrder(T);
    printf("\n");
    InOrder(T);
    printf("\n");
}


void PreOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    printf("%c",T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

void InOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    InOrder(T->lchild);
    InOrder(T->rchild);
    printf("%c",T->data);
}

//-------------------------------------------

void InitStack(SqStack* S){
    S->top=-1;
}

void Push(SqStack* S, BiTNode* T){
    if(S->top==MaxSize-1){
        return;
    }
    S->data[++S->top]=T;
}

BiTNode* Pop(SqStack* S){
    if(S->top==-1){
        return NULL;
    }
    return S->data[S->top--];
}

BiTNode* GetTop(SqStack* S){
    if(S->top==-1){
        return NULL;
    }
    return S->data[S->top];
}

int IsEmptyStack(SqStack* S){
    if(S->top==-1){
        return 0;
    }
    return -1;
}