二叉树的遍历：先序遍历，中序遍历，后序遍历

二叉树的遍历：
大家都知道分成先序遍历，中序遍历，后序遍历。
先序遍历的顺序是根节点-左孩子（左节点）-右孩子（右节点）
中序遍历的顺序是左孩子（左节点）-根节点-右孩子（右节点）
后序遍历的顺序是左孩子（左节点）-右孩子（右节点）-根节点
遍历二叉树可以用递归算法，也可以不用递归算法

话不多说，直接上代码

#include<stdio.h>
#include<malloc.h>

typedef struct Node
{
    int data;
    struct Node *lchild,*rchild;//左孩子右孩子 
}BTNode;
/*
定义一个方法，在二叉树中增加一个节点
二叉树是中序遍历：从小到大有序 ，递归实现 
*/
BTNode * insertNodeBTree(BTNode *root,int d)
{
    BTNode *q=root;
    //动态分配内存
    BTNode *p=(BTNode *)malloc(sizeof(BTNode)); 
    //将d放入节点的数据域 
    p->data=d;
    p->lchild=p->rchild=NULL;
    //遍历查找节点应该存放的位置
    //如果root为空，root指向新增的节点
    if(q==NULL)
    {
        q=p;
    }
    //如果d<q->data并且左孩子为空，d作为左孩子 
    if(d<q->data)
    {
        if(q->lchild==NULL)
        {
            q->lchild=p;
        }
        else 
        //如果左孩子不为空，在左子树中查找位置
        {
        insertNodeBTree(q->lchild,d);
        }
    }
    //如果d>q->data并且右孩子为空，d作为右孩子 
    if(d>q->data)
    {
        if(q->rchild==NULL)
        {
            q->rchild=p;
        }
        else 
        //如果右孩子不为空，在右子树中查找位置
        {
        insertNodeBTree(q->rchild,d);
        }
    }
    //返回根节点的指针(root) 
    return q;
}
/*
创建二叉树，以输入-1结束 
*/
BTNode *createBTree(BTNode *root)
{
    int a;
    printf("请输入二叉树的节点，输入-1结束！\n");
    scanf("%d",&a);
    while(a!=-1)
    {
        root=insertNodeBTree(root,a);
        scanf("%d",&a);
    }
    return root;
}
//先序排序：根-左-右，用递归实现 
void firstOrder(BTNode *root)
{
    if(root!=NULL)
    {
        printf("%d\t",root->data);
        firstOrder(root->lchild);
        firstOrder(root->rchild);
    }
} 

//先序排序：根-左-右，不用递归实现 

void preOderTree(BTNode * root) 
{
    //定义一个顺序栈==放右之树,p是保存马上访问的地址 
    BTNode *stack[50],*p,*q; 
    int top=0;//设置栈顶指针 
    p=root;
    if(root==NULL)
    {
        printf("二叉树为空！\n");
        return;
    } 
    do
    {
        //输出根节点 
        printf("%d\t",p->data);
        //q保存右孩子的指针 
        q=p->rchild;
        //如果右孩子不为空，将右孩子入栈 
        if(q!=NULL)
        {
            stack[top++]=q;         
        }
        //p保存左孩子的指针
        p=p->lchild;
        //如果左孩子为空,右孩子出栈
        if(p==NULL&&top>0) 
        {
            p=stack[--top];
        }
    }while(p!=NULL);
}

//中序排序：左-根-右，用递归实现 
void inOrder(BTNode *root)
{
    if(root!=NULL)
    {
        inOrder(root->lchild);
        printf("%d\t",root->data);
        inOrder(root->rchild);
    }
} 

//中序排序：左-根-右，不用递归实现 
void inOrderTree(BTNode *root)
{
    //定义一个顺序栈
    BTNode *stack[50],*p,*q; 
    //栈顶指针
    int top=0;
    p=root;
    //二叉树不为空，遍历
    if(root==NULL)
    {
        printf("二叉树为空!\n");
        return; 
    } 
         do
        {
            //把二叉树的左子树的根依次入栈，直到p为空为止
            while(p!=NULL)
            {
                stack[top++]=p;
                p=p->lchild;
            }   
            if(top==0){
                return;
            }
            else{
                p=stack[--top]; //取栈顶元素 
                printf("%d\t",p->data); //输出栈顶元素 
                p=p->rchild; //指向右子树的根节点 
            }

        }while(1);
} 


//后序排序：左-右-根， 用递归实现 
void postOrder(BTNode *root)
{
    if(root!=NULL)
    {
        postOrder(root->lchild);
        postOrder(root->rchild);
        printf("%d\t",root->data);
    }
} 




/*
遍历二叉树
*/
void preTree(BTNode *root)
{
    if(root!=NULL)
    {
        preTree(root->lchild);
        printf("%d\t",root->data);
        preTree(root->rchild);
    }
}
main()
{
    BTNode *root=NULL;
    /*
    //此注释掉的方法是将二叉树之星中序排列 ，实现从小到大的排列 
    root=insertNodeBTree(root,10);
    root=insertNodeBTree(root,9);
    root=insertNodeBTree(root,20);
    root=insertNodeBTree(root,5);
    root=insertNodeBTree(root,1);
    root=insertNodeBTree(root,2);
    preTree(root);
    */
    root=createBTree(root);
    printf("先序遍历用递归实现为：\n");
    firstOrder(root);
    printf("\n先序遍历不用递归实现为：\n");
    preOderTree(root);  
    printf("\n中序遍历用递归实现为：\n");
    inOrder(root);
    printf("\n不用递归中序遍历为：\n");
    inOrderTree(root); 

    printf("\n后序遍历用递归实现为：\n");
    postOrder(root);
}

大家可以运行一下，代码都是给全了的