急求二叉树后序非递归遍历算法和非递归深度算法，要求不使用堆栈！可以使用数组,该如何解决

#include <stdio.h>
#include <stdlib.h>
#include "head.h"
#define MAXLEN  100    //队列的最大长度

typedef char DataType ;  //定义二叉树结点数据域类型
typedef struct treenode{ //定义二叉树结点类型
    DataType data ;
    struct treenode *lchild, *rchild ; 
} BinTreeTp ;
typedef BinTreeTp *BinTreePtr ; //定义二叉树结点指针类型

/***********非递归遍历二叉树**************/
//先序遍历
void pre(BinTreePtr T)
{
 BinTreeTp *p,*stack[MAXLEN];
 int top=0;
 if (T!=NULL)
 {
  stack[top]=T;
  while(top>=0)
  {
   p=stack[top--];
   printf("%c",p->data);
   if (p->rchild!=NULL)
   {
    stack[++top]=p->rchild;
   }
   if (p->lchild!=NULL)
   {
    stack[++top]=p->lchild;
   }
  }

 }
 
}

//中序遍历
void middle(BinTreePtr bt)
{
    BinTreeTp *p=bt, *stack[MAXLEN]; //p表示当前结点，栈stack[]用来存储结点
    int top=0;
    
    if(p != NULL)
    {
        while(top >= 0)
        {
            if(p != NULL) //左孩子结点先入栈
            {
                stack[top++] = p; //当前结点入栈
                p = p->lchild; //寻找左孩子结点
            }
            else //找到最左边的孩子结点后
            {
                if(top == 0) //表示全部元素均已输出，结束输出
                    break;
                p = stack[--top];//栈顶元素出栈
                printf("%c", p->data); //输出该结点
    p = p->rchild; //处理其右孩子结点
            }
        }
    } 
 else
  printf("空树");
}

//建二叉树操作，本操作创建一个由先序顺序输入的字符组成的二叉树。
void CreatBinTree(BinTreePtr *T)
{
  DataType ch ;
  if ((ch = getchar()) == '#')
      *T = NULL ;
  else {
      *T = (BinTreeTp *)malloc(sizeof(BinTreeTp)) ;
      (*T)->data = ch ;
      CreatBinTree(&(*T)->lchild) ;
      CreatBinTree(&(*T)->rchild) ;
  }
}

//二叉树的复制
void copytree(BinTreePtr T,BinTreePtr *R)
{
 if (T != NULL)
 {
  *R=(BinTreeTp *)malloc(sizeof(BinTreeTp));
  (*R)->data=T->data;
  printf("%c",(*R)->data);
  copytree(T->lchild,&(*R)->lchild);
  copytree(T->rchild,&(*R)->rchild);
 }
 else
  (*R)=NULL;
}

/**************递归遍历*****************/
//先序遍历二叉树操作
void PreOrder(BinTreePtr T)
{
   if (T) {
    printf("%c", T->data) ;
    PreOrder(T->lchild) ;
      PreOrder(T->rchild) ;
   }
}

//中序遍历二叉树操作
void InOrder(BinTreePtr T)
{
   if (T) {
      InOrder(T->lchild) ;
      printf("%c", T->data) ;
      InOrder(T->rchild) ;
   }
}
//后序遍历二叉树操作
void PostOrder(BinTreePtr T)
{
   if (T) {
      PostOrder(T->lchild) ;
      PostOrder(T->rchild) ;
      printf("%c", T->data) ;
   }
}
//层次遍历二叉树操作
void LevelOrder(BinTreePtr T)
{
   //定义一个存放二叉树结点指针的队列，循环队列并少用一个空间
   BinTreeTp *queue[MAXLEN] ; 
   int front, rear ;  //定义队列的队头和队尾指针
   BinTreeTp *p ;  //定义待处理二叉树结点的指针

   front = rear = 0 ; //循环队列初始化
   p = T ; //指向根结点
   if ((rear + 1) % MAXLEN == front) return ; //队列满，返回
   rear = (rear + 1) % MAXLEN ;//否则入队列
   queue[rear] = p ;
   while (front != rear) {  //当队列非空时，执行循环
      front = (front + 1) % MAXLEN ; //修改队头指针
      p = queue[front] ; //从队头取得数据

      printf("%c", p->data) ;  //遍历
      if (p->lchild) { //如果左孩子指针不为空，则入队列
  if ((rear + 1) % MAXLEN == front) return ;
  rear = (rear + 1) % MAXLEN ;
  queue[rear] = p->lchild ;
      }
      if (p->rchild) { //如果右孩子指针不为空，则入队列
  if ((rear + 1) % MAXLEN == front) return ;
  rear = (rear + 1) % MAXLEN ;
  queue[rear] = p->rchild ;
      }
   }
}
//求二叉树的叶子结点个数
int leafNum(BinTreePtr T)
{
 static int num=0;
 if (T != NULL)
 {
  if (T->lchild==NULL&&T->rchild==NULL)
  {
   ++num;
  }
  else
  {
   leafNum(T->lchild);
   leafNum(T->rchild);
  }
 }
 return num;
}

//求二叉树深度（第一层为1）
int deeptree(BinTreePtr T)
{
 static int m=0,n=0,max=0;
 if (T != NULL)
 {
  n=deeptree(T->lchild);
  m=deeptree(T->rchild);
  if (m>n)
   max=m;
  else
   max=n;
  return max+1;
 }
 else 
 return 0;
}
//求二叉树所有的结点个数操作。采用后序遍历思想。如果二叉树为空，
//总结点个数为零；否则后序求出左子树总结点个数和后序求出
//右子树总结点个数，总结点个数为左右之和再加上1。
int CountTree(BinTreePtr T)
{
   int lnum, rnum ;
   if (!T) return 0 ;
   else {
      lnum = CountTree(T->lchild) ;
      rnum = CountTree(T->rchild) ;
      return lnum + rnum + 1 ;
   }
}


//主程序
void main(void)
{
   BinTreePtr T,R;
   printf("请以先序顺序输入要创建的二叉树:/n") ;
   CreatBinTree(&T) ;
   printf("叶子个数为%d,  总结点个数为%d", leafNum(T),CountTree(T)) ;
   printf("/n二叉树的深度：%d/n",deeptree(T));
   printf("********非递归遍历：********/n");
   printf("先序遍历：") ;
   pre(T);
   printf("/n中序遍历：") ;
   middle(T);
   printf("/n********递归遍历：********/n");
   printf("先序遍历：") ;
   PreOrder(T) ;  //先序遍历
   printf("/n中序遍历：") ;
   InOrder(T) ;  //中序遍历
   printf("/n后序遍历：") ;
   PostOrder(T) ;  //后序遍历
   printf("/n层次遍历：") ;
   LevelOrder(T) ; //层次遍历
   printf("/n二叉树的复制(并先序输出二叉树)：");
   copytree(T,&R);
   printf("/n") ;
}