Que and Stack

#ifndef __QUE_H__
#define __QUE_H__

#define QUE_SZ 1024

typedef struct que{
   int hd;
   int tl;
   int nd[QUE_SZ];
}QUE;

int que_init(QUE *q);
int que_empty(QUE *q);
int que_full(QUE *q);
int que_head(QUE *q);
int que_tail(QUE *q);
int que_clr(QUE *q);
int que_size(QUE *q);

#endif/*__QUE_H__*/

#include "que.h"

int que_init(QUE *q)
{
   int i;
   if(NULL==q)
      return -1;
   q->hd=0;
   q->tl=0;
   for(i=0;i<QUE_SZ;i++)
      q->nd[i]=0;
   return 0;
}

int que_empty(QUE *q)
{
   return q->hd==q->tl;
}

int que_full(QUE *q)
{
   return (q->tl+1)&(QUE_SZ-1)==q->hd;
}

int que_head(QUE *q)
{
   int n=-1;
   if(!que_empty(q)){
      n=q->nd[q->hd];
      q->hd=(q->hd+1)&(QUE_SZ-1);
   }
   return n;
}

int que_tail(QUE *q,int n)
{
   if(que_full(q))
      return 0;
   q->nd[q->tl]=n;
   q->tl=(q->tl+1)&(QUE_SZ-1);
   return 1;
}

int que_clr(QUE *q)
{
   if(que_empty(q))
      return 0;
   q->hd=q->tl=0;
   return 1;
}

int que_size(QUE *q)
{
   int size=0;
   if(q->hd==q->tl)
      size=0;
   else
      size=(q->tl-q->hd+QUE_SZ)&(QUE_SZ-1);
   return size;
}

#ifndef __STK_H__
#define __STK_H__

#define STK_SZ 1024

typedef struct stk{
   int top;
   int nd[STK_SZ];
}STK;

int stk_init(STK *s);
int stk_empty(STK *s);
int stk_full(STK *s);
int stk_push(STK *s,int n);
int stk_pop(STK *s);
int stk_clr(STK *s);
int stk_size(STK *s);

#endif/*__STK_H__*/

#include "stk.h"

int stk_init(STK *s)
{
   int i=0;
   if(NULL==s)
      return -1;

   s->top=0;
   for(;i<STK_SZ;i++)
      s->nd[i]=0;
   return 1;
}

int stk_empty(STK *s)
{
   return 0==s->top;
}

int stk_full(STK *s)
{
   return STK_SZ==s->top;
}

int stk_push(STK *s,int n)
{
   if(STK_SZ==s->top)
      return 0;
   s->nd[s->top]=n;
   s->top++;
   return 1;
}

int stk_pop(STK *s)
{
   if(0==s->top)
      return 0;
   s->top--;
   return s->nd[s->top];
}

int stk_size(STK *s);
{
   return s->top;
}

int stk_clr(STK *s)
{
   s->top=0;
   return 1;
}