查找二叉树指定结点的层次

我建了两个栈，每次遍历一个层次以后就换一个栈，我只想到了这种方法，但感觉这做法不是很好。

/*
假设二叉树采用链式方式存储，t为其根结点，编写一个函数int Depth(bintree t, char x)，求值为x的结点在二叉树中的层次。
*/
#include "bintree.h"
char *a="ABC##D##EF#G###";          /*扩充二叉树序树t的前序序列*/

/*
     函数Depth，功能：求结点x所在的层次
*/
int Depth(bintree t,char x)
{
    int k=1,flag=1;
    binnode *p=t;
    binnode *q;
    seqstack L1,L2;    
    init(&L1);
    init(&L2);
    push(&L1,p);
    while(1)
    {
       if(flag==1)
       {
          while(!empty(&L1))
          {
              q=pop(&L1);
              if(q->data==x)  return k;
              if(q->lchild!=NULL)  push(&L2,q->lchild);
              if(q->rchild!=NULL)  push(&L2,q->rchild);
          }
          k++;
          flag=0;
       }
       else if(flag==0)
       {
          while(!empty(&L2))
          {
              q=pop(&L2);
              if(q->data==x)  return k;
              if(q->lchild!=NULL)  push(&L1,q->lchild);
              if(q->rchild!=NULL)  push(&L1,q->rchild);
          }
          k++;
          flag=1;
       }
    }
}

int main()
{  bintree root;
   char x;
   int k=0;
   root=creatbintree();
   printf("请输入树中的1个结点值：
");
   scanf("%c",&x);
   k=Depth(root,x);
   printf("%c结点的层次为%d
",x,k);
}

#include <stdio.h>
#include <stdlib.h>
#define N 100
extern char *a;     /*存放扩充二叉树的前序序列*/
typedef struct node /*二叉树结构定义*/
{
    char data;
    struct node *lchild,*rchild;
}binnode;
typedef binnode *bintree;

/*函数creatbintree (根据扩充二叉树的前序序列(字符串a)建立二叉树t的存储结构*/
bintree  creatbintree()
{
    char ch=*a++;
    bintree t;
    if  (ch=='#')  t=NULL;
    else
    { t=(bintree)malloc(sizeof(binnode));
      t->data=ch;
      t->lchild=creatbintree();
      t->rchild=creatbintree();
    }
    return t;
}

void preorder(bintree t)  /*前序递归遍历二叉树*/
{
    if (t)
    {
        printf("%c",t->data);
        preorder(t->lchild);
        preorder(t->rchild);
    }
}
void postorder(bintree t)  /*后序递归遍历二叉树*/
{
    if (t)
    {

        postorder(t->lchild);
        postorder(t->rchild);
        printf("%c",t->data);
    }
}

/*顺序栈定义*/
typedef struct
{
    bintree data[N];
    int top;
    int tag[N];
}seqstack;

void init(seqstack *s)   /*初始化空栈*/
{
    s->top=-1;
}
int empty(seqstack *s)   /*判断栈是否为空*/
{
    if (s->top>-1) return 0;
    else return 1;
}
int full(seqstack *s)   /*判断栈是否为满*/
{
    if (s->top==N-1) return 1;
    else return 0;
}
void push(seqstack *s ,bintree x)   /*进栈*/
{
    if (!full(s))
        s->data[++s->top]=x;
}
bintree pop(seqstack *s)            /*出栈*/
{
    if (!empty(s))
        return s->data[s->top--];
}