问题描述

在二叉树中查找值为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;
}