二叉树的递归遍历与非递归遍历

二叉树的递归遍历与非递归遍历

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

/* 本程序实现二叉树的创建，递归遍历与非递归遍历 */
 typedef struct TNODE
 {
    int data;
    struct TNODE *lchild,*rchild;
 }TNode,*PNode;

 //构造二叉树
 PNode createTree()
 {
    PNode pnode;
    int data;
    printf("输入节点值:\n");
    scanf("%d",&data);
    if(data==0)
    {
        pnode = NULL;
     }
     else
     {
        pnode = (PNode)malloc(sizeof(TNode));
        if(pnode ==NULL)
        {
            printf("创建二叉树节点申请失败!\n");
            exit(-1);
        }
        pnode->data = data;
        pnode->lchild = createTree();
        pnode->rchild = createTree();
     }

    return pnode;
  } 

  //递归先序遍历二叉树
void preOrderTree(PNode root)
{
   if(root!=NULL)
   {
        printf("%d ",root->data);
        preOrderTree(root->lchild);
        preOrderTree(root->rchild);
   }
}

//中序
void inOrderTree(PNode root)
{
    if(root!=NULL)
    {
        inOrderTree(root->lchild);
        printf("%d ",root->data);
        inOrderTree(root->rchild);
    }
 } 
 //后序
void postOrderTree(PNode root)
{
    if(root!=NULL)
    {
        postOrderTree(root->lchild);
        postOrderTree(root->rchild);
        printf("%d ",root->data);
    }
 } 

 //非递归遍历
 typedef struct SNODE
 {
    PNode pnode; //存放树节点指针
    struct SNODE *next; 
  } Snode,*PSnode;

  typedef struct STACK
  {
    PSnode top;
    PSnode bottom;
  }Stack,*PStack;
//初始化一个空栈用于存放遍历过程中的临时树的节点指针 
PStack initStack()
{
    PStack pstack = (PStack)malloc(sizeof(Stack));
    PSnode psnode = (PSnode)malloc(sizeof(Snode));
    if(psnode ==NULL)
    {
        printf("init satck error!\n");
        exit(-1);
    }
    psnode->next = NULL;
    pstack->bottom = psnode;
    pstack->top = psnode;
    return pstack;
 } 
 //判断栈是否为空
bool isEmpty(PStack pstack)
 {
    if(pstack->bottom == pstack->top)
        return true;

    return false;
  } 
//节点指针入栈
void push(PStack pstack,PNode pnode)
{
    PSnode psnode = (PSnode)malloc(sizeof(Snode));
    if(psnode ==NULL)
    {
        printf("init satck error!\n");
        exit(-1);
    }

    psnode->pnode = pnode;
    psnode->next = pstack->top;
    pstack->top = psnode;
//  printf("%d入栈\n",pnode->data);   
 } 

//获取栈顶元素树指针节点
PNode top(PStack pstack){
    if(isEmpty(pstack))
    {
        printf("top stack is NULL!\n");
        return NULL;
    }
//  printf("获取栈顶元素%d\n",pstack->top->pnode->data);
    return pstack->top->pnode;
}

//出栈
void pop(PStack pstack)
{
    if(isEmpty(pstack))
    {
        printf(" pop stack is NULL!\n");
        exit(-1);
    }
    PSnode psnode = pstack->top;
    pstack->top = psnode->next;
//  printf("出栈%d\n",psnode->pnode->data);
    free(psnode); 
 } 
 //遍历栈元素
 void printStack(PStack pstack)
 {
    if(isEmpty(pstack))
    {
        printf("stack为空\n");
     }
     else
     {
        PSnode p = pstack->top;
        while(p!= pstack->bottom)
        {
            printf("栈元素%d\n",p->pnode->data);
            p = p->next;
        }
     }

  } 
 //非递归先序遍历
void preOrder(PNode root)
{
    PStack pstack;
    pstack = initStack();
    PNode p = root;
    while(p!=NULL || !isEmpty(pstack))
    {
        while(p!=NULL)
        {
            printf("%d ",p->data);
            push(pstack,p);
//          printStack(pstack);
            p = p->lchild;
        }

        if(!isEmpty(pstack))
        {
            p = top(pstack);
            pop(pstack);
            p = p->rchild;
        }
    }   
}

//非递归中序遍历
void inOrder(PNode root)
{
    PStack pstack = initStack();
    PNode p = root;
    while(p!=NULL || !isEmpty(pstack))
    {
        while(p!=NULL)
        {
            push(pstack,p);
            p = p->lchild;
        }

        if(!isEmpty(pstack))
        {
            p = top(pstack);
            printf("%d ",p->data);  
            pop(pstack);
            p = p->rchild;
        }
    }
 } 

 //层次遍历数，shiyongduilie使用队列实现

 typedef struct QNODE
{
    PNode pnode;
    struct QNODE *next;
}QNode,*PQNode; 
typedef struct QUEUE 
{
    PQNode front;
    PQNode rear;
}Queue,*PQueue;

PQueue initQueue()
{
    PQueue pqueue = (PQueue)malloc(sizeof(Queue));
    PQNode pqnode = (PQNode)malloc(sizeof(QNode));
    if(pqnode==NULL)
    {
        printf("initqueue error\n");
        exit(-1); 
    }
    pqueue->front = pqueue->rear = pqnode;
    pqueue->rear->next = NULL;
    return pqueue;
}
bool empty(PQueue pqueue)
{
    if(pqueue->front == pqueue->rear)
        return 1;
    return 0;
}
void enQueue(PQueue pqueue,PNode pnode)
{
    if(pqueue==NULL)
    {
        printf("queue is null\n");
        exit(-1);
    }
    PQNode pqnode = (PQNode)malloc(sizeof(QNode));
    if(pqnode==NULL)
    {
        printf("push queue node error\n");
        exit(-1);
    }
    pqnode->pnode = pnode;
    pqnode->next = NULL;
    pqueue->rear->next = pqnode;
    pqueue->rear = pqnode;
}
PNode getQueue(PQueue pqueue)
{
    if(empty(pqueue))
    {
        printf("queue is NULL top\n");
        exit(-1);
    }
    return pqueue->front->next->pnode;
}

void deQueue(PQueue pqueue)
{
    if(empty(pqueue))
    {
        printf("queue is NULL pop\n");
        exit(-1);
    }
    PQNode pqnode=pqueue->front->next;
    pqueue->front->next = pqnode->next;
//  printf("%d出队\n",pqnode->pnode->data);
    if(pqnode==pqueue->rear)
    {
        pqueue->rear = pqueue->front;
    }
    free(pqnode);
} 

void levelOrder(PNode root)
{
    PNode p = NULL;
    PQueue pqueue = initQueue();
    enQueue(pqueue,root);
    while(!empty(pqueue))
    {
        p = getQueue(pqueue);
        printf("%d ",p->data);
        deQueue(pqueue);
        if(p->lchild!=NULL)
        {
            enQueue(pqueue,p->lchild);
        }
        if(p->rchild!=NULL)
        {
            enQueue(pqueue,p->rchild);
        }
    }
}


int main(int argc, char *argv[]) {
    PNode root;
    root = createTree();
    preOrderTree(root);
    printf("\n");

    preOrder(root);
    printf("\n");

    printf("中序遍历\n");
    inOrderTree(root);
    printf("\n");
    inOrder(root);
    printf("\n");

    printf("后序遍历\n");
    postOrderTree(root);
    printf("\n");
    printf("层次遍历\n");
    levelOrder(root);
    printf("\n");
    return 0;
}