面试题 19

1 题目描述

请输入一个函数，输入一个二叉树，该函数输出它的镜像

2 算法描述

• 遍历二叉树，交换（如果都存在）左右孩子节点
• 可以选择深度遍历、层次遍历

---

3 C 语言实现

• 采用先序递归遍历
• 采用先序非递归遍历

#include<stdio.h>

// Tree
typedef int ElemType;
typedef struct node{
    ElemType data;
    struct node *lchild,*rchild;
}TNode,*Tree;

// Stack node1即为栈元素SNode也为队元素QNode
typedef struct node1{
    TNode* data;
    struct node1 *next;
}SNode,QNode,*Stack;

//初始化头结点
void initStack(Stack* stack){
    (*stack)=(SNode*)malloc(sizeof(SNode));
    (*stack)->data=NULL;
    (*stack)->next=NULL;
}
//所有操作都在表头进行,头插法
int push(Stack stack,TNode* data){
    SNode *push;
    //如果Stack尚未初始化
    if(stack==NULL) return 0;
    push=(SNode*)malloc(sizeof(SNode));
    push->data=data;
    push->next=stack->next;
    stack->next=push;
}
//出栈
int pop(Stack stack,TNode** popVlaue){
    //如果Stack为空
    if(isEmpty(stack)) return 0;
    SNode *pop=stack->next;
    *popVlaue=pop->data;
    stack->next=pop->next;
    free(pop);
    return 1;
}
//获得栈顶元素
int getTop(Stack stack,TNode** topVlaue){
    //如果Stack为空
    if(isEmpty(stack)) return 0;
    *topVlaue=stack->next->data;
    return 1;
}
//判断是否为空
int isEmpty(Stack stack){
    return stack!=NULL&&stack->next==NULL?1:0;
}
//创建二叉树
TNode* createTree(){
    ElemType data;
    scanf("%d",&data);
    TNode* node;
    if(data==0) return NULL;
    node=(TNode*)malloc(sizeof(TNode));
    node->data=data;
    node->lchild=createTree();
    node->rchild=createTree();
    return node;
}
//先序遍历
void preOrder(TNode* node){
    if(node==NULL) return;
    printf("%d",node->data);
    preOrder(node->lchild);
    preOrder(node->rchild);
}

//非递归先序遍历
void _preOrder(Tree tree){
    Stack stack;
    initStack(&stack);
    TNode *p=tree;
    while(p!=NULL||!isEmpty(stack)){
        if(p!=NULL){
            printf("%d",p->data);
            push(stack,p);
            p=p->lchild;
        }else{
            pop(stack,&p);
            p=p->rchild;
        }
    }
}
void mirroTree(TNode* node){
    TNode* temp;
    if(node==NULL) return;
    if(node->lchild==NULL&&node->rchild==NULL){
        return;
    }
    temp=node->lchild;
    node->lchild=node->rchild;
    node->rchild=temp;
    mirroTree(node->lchild);
    mirroTree(node->rchild);
}

void mirroTree_1(TNode* tree){
    Stack stack;
    initStack(&stack);
    TNode *p=tree;
    TNode* temp;
    while(p!=NULL||!isEmpty(stack)){
        if(p!=NULL){
            if(!(p->lchild==NULL&&p->rchild==NULL)){
                temp=p->lchild;
                p->lchild=p->rchild;
                p->rchild=temp;
            }
            push(stack,p);
            p=p->lchild;
        }else{
            pop(stack,&p);
            p=p->rchild;
        }
    }
}

void main(){
   Tree tree;
   tree=NULL;
   printf("%s:","请输入二叉树的元素");
   tree=createTree();
   printf("\n%s:","先序递归遍历原始二叉树结果");
   preOrder(tree);

   printf("\n%s:","先序递归遍历镜像二叉树结果");
   mirroTree(tree);
   preOrder(tree);

   printf("\n%s:","先序递归遍历镜像二叉树镜像结果");
   mirroTree_1(tree);
   preOrder(tree);
}