递归：

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

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void PreOrderTraverse(BiTree T)//二叉树的先序遍历
{
    if(T==NULL)return ;
    printf("%c ",T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

void MidOrderTraverse(BiTree T)//二叉树的中序遍历
{
   if(T==NULL)return ;
   MidOrderTraverse(T->lchild);
   printf("%c ",T->data);
   MidOrderTraverse(T->rchild);
}

void ReaOrderTraverse(BiTree T)//后序遍历
{
    if(T==NULL)return;
    ReaOrderTraverse(T->lchild);
    ReaOrderTraverse(T->rchild);
    printf("%c ",T->data);
}
void CreateBiTree(BiTree *T)
{
    char ch;
    scanf("%c",&ch);

    if(ch=='#')
    {
      *T=NULL;
      return;
    }
    else
    {
        *T=(BiTree  )malloc(sizeof(BiTNode));
        (*T)->data=ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}
int main()
{
    BiTree T;
    CreateBiTree(&T);
    printf("Pre:");
    PreOrderTraverse (T);
    printf("\nMid:");
    MidOrderTraverse(T);
    printf("\nRea:");
    ReaOrderTraverse(T);
    return 0;
}
//ABD###CE##FG###

非递归

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

#define MaxSize 100

typedef struct LTree
{
  char data;
  struct LTree *LChild,*RChild;
}LTree,*BiTree;

typedef struct LStack
{
  BiTree Stack[MaxSize];
  int top;
}LStack;

void InitStack(LStack *S);
bool JudgeEmpty(LStack *S);
void CreateBiTree(BiTree *T);
void PreOrderTraverse(BiTree T,LStack *S);
void MidOrderTraverse(BiTree T,LStack *S);
void ReaOrderTraverse(BiTree T,LStack *S);

/*初始化栈*/
void InitStack(LStack *S)
{
  S->top = -1;
}
/*判断栈是否为空*/
bool JudgeEmpty(LStack *S)
{
  if(S->top == -1)return true;
  else return false;
}
/*创建二叉树*/
void CreateBiTree(BiTree *T)
{
  char ch;
  scanf("%c",&ch);

  if(ch == '#')
  {
    *T = NULL;
    return;
  }
  else
  {
    *T = (BiTree)malloc(sizeof(LTree));
    (*T)->data = ch;
    CreateBiTree(&(*T)->LChild);
    CreateBiTree(&(*T)->RChild);
  }
}
/*前序遍历*/
void PreOrderTraverse(BiTree T,LStack *S)
{
  InitStack(S);
  BiTree p = T;

  printf("Pre:");
  while (p || !JudgeEmpty(S))//遍历结束且栈为空时结束
  {
    if(p)
    {
      printf("%c ",p->data);//输出根节点
      S->Stack[++S->top] = p;//记录父节点
      p = p->LChild;//遍历左节点
    }
    else
    {
      p = S->Stack[S->top--];//寻找根节点
      p = p->RChild;//遍历右节点
    }
  }
}
/*中序遍历*/
void MidOrderTraverse(BiTree T,LStack *S)
{
  InitStack(S);
  BiTree p = T;

  printf("Mid:");
  while (p || !JudgeEmpty(S))
  {
    if(p)
    {
      S->Stack[++S->top] = p;
      p = p->LChild;
    }
    else
    {
      p = S->Stack[S->top--];//获取根节点
      printf("%c ",p->data);
      p = p->RChild;
    }
  }
}
/*后序遍历*/
void ReaOrderTraverse(BiTree T,LStack *S)
{
  InitStack(S);
  BiTree p = T,r = NULL;

  printf("Rea:");
  while (p || !JudgeEmpty(S))
  {
    if(p)
    {
      S->Stack[++S->top] = p;
      p = p->LChild;
    }
    else
    {
      p = S->Stack[S->top];
      if(p->RChild && p->RChild != r)//要输出根节点之前应该输出的一个节点是右节点
        p = p->RChild;               //若右节点不为空 并且 右节点 不等于r（前一个访问的节点）
                                     //说右有节点没有被访问过
      else
      {
         --S->top;
         printf("%c ",p->data);
         r = p;
         p = NULL;
      }
    }
  }
}
int main(int argc, char const *argv[]) {
  BiTree T;
  LStack S;
  CreateBiTree(&T);
  PreOrderTraverse(T,&S);printf("\n");
  MidOrderTraverse(T,&S);printf("\n");
  ReaOrderTraverse(T,&S);printf("\n");
  return 0;
}