c语言 队列

栈是限定尽在表尾进行插入或删除的线性表（先进先出）。对栈来说，表尾称为栈顶，表头称为栈底。
现在以下面的程序说明对栈的基本操作。
#include         
#include
#include           

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

#define STACK_INIT_SIZE 12 
#define ADD 2

typedef struct{
 int *base;
 int *top;
 int stacksize;
}Stack;

int InitStack(Stack *S)                      //初始化
{
 S->base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));
 if(!S->base)
  exit(1);
 S->top=S->base;
 S->stacksize=STACK_INIT_SIZE;
 return OK;
}

int Push(Stack *S,int e)                    //入栈
{
 if(S->top - S->base >= S->stacksize)
 {
  S->base = (int *)realloc(S->base,(S->stacksize+ADD)*sizeof(int));
  if(!S->base) 
   exit(1);
  S->top=S->base+S->stacksize;
  S->stacksize+=ADD;
 }
 *(S->top)++=e;
 return OK;
}

int Pop(Stack *S,int *e)                    //出栈
{
   if(S->top==S->base)
     return ERROR;
   *e=*(--S->top);
   return OK;
}

int visit(int c)
 {
   printf("%d ",c);
   return OK;
 }

int StackTraverse(Stack S,int (*visit)(int))   //遍历
 {
   while(S.top>S.base)
     visit(*S.base++);
   printf("\n");
   return OK;
 }

int StackEmpty(Stack S)                        //判断栈是否为空
 {
   if(S.top == S.base)
     return TRUE;
   else
     return FALSE;
 }

int DestroyStack(Stack *S)                     //销毁栈
 {
   free(S->base);
   S->base=NULL;
   S->top=NULL;
   S->stacksize=0;
   return OK;
 }

int ClearStack(Stack *s)                      //栈置为空 
 {  
   s->top = s->base;
   return OK;
 }

 int StackLength(Stack S)                    //栈的深度
 {
   return (S.top-S.base);
 }

int GetTop(Stack S,int *e)                  //获取栈顶元素
{
 if(S.top==S.base)
  return ERROR;
 *e = *(S.top-1);
 return OK;
}

int main(void)
 {
 int j;
 Stack s;
 int e;
 if(InitStack(&s))                                        //新建
  for(j=0;j<5;j++)
   Push(&s,j);                                          //入栈

 printf("栈中元素依次为：");  
 StackTraverse(s,visit);                                        //第一次遍历

 Pop(&s,&e);                                                    //出栈
 printf("弹出的栈顶元素 e=%d\n",e);

        printf("栈中元素依次为：");
 StackTraverse(s,visit);                                        //次遍历

 
 printf("栈空否：%d (1:空 0:否)\n",StackEmpty(s));              //判断栈是否为空
  
 GetTop(s,&e);
 printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));       //获取栈顶元素，栈的深度

 ClearStack(&s);                                                //清空栈
 printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));

 DestroyStack(&s);                                             //销毁栈
 printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top,s.base, s.stacksize);

 return 0;
}

 

 

 

 

#include
#include
#include

#define STACK_SIZE 5
#define OK 1
#define ERROR 0

typedef struct  note
{
 int x;
 int y;
}Note;

typedef struct
{
 Note *base;
 Note *top;
 int stack_size;
}Stack;

int init_stack(Stack *p)
{
p->base=malloc(STACK_SIZE * sizeof(struct note));
if(!p->base)
exit(1);
p->top=p->base;
p->stack_size=STACK_SIZE;
return OK;
}

int push(Stack *p,Note e)
{
 if(p->top - p->base >= p->stack_size)
     return ERROR;
 else
 *(p->top)++=e;
 return OK;
}

int Pop(Stack *p,Note *e)                   //出栈
{
   if(p->top==p->base)
     return ERROR;
   *e=*(--p->top);
   return OK;
}

int visit(Note c,Note q)
 {
   if( c.x!=q.x || c.y!=q.y)
   return OK;
   else
   return ERROR;
 }

int stack_traverse(Stack p,int (*visit)(Note, Note),Note q)   //遍历查询
 {
   int flag=1;
   while(p.top > p.base)
   {
    if(0==visit(*p.base++,q))
  return ERROR;
   }
   return OK;
 }

int stack_traverse_print(Stack p)   //遍历打印
 {
   while(p.top>p.base)
   {
    printf("%d %d\n",p.base->x,p.base->y);
    p.base++;
   }
return OK;
 }

int main()
{  
 int x=0,y=0,i=0;
    int flag=1;
 Note q;
 Stack p;
 init_stack(&p);   //栈出始化
 while(flag)
 {
 printf("请输入 X and Y:");
 scanf("%d %d",&x,&y);
        q.x=x;
 q.y=y;

 if(1==stack_traverse(p,visit,q))              //遍历，若栈中已有将加入的数据，则不加入
 {
  if(0==push(&p,q))                          //出栈
  {
   printf("Overflow\n");
   break;
  }
 }
 else
  printf("The Stack already has this element\n");

     printf("是否继续增加元素(flag=1):");
     scanf("%d",&flag);
 }
stack_traverse_print(p);
return 0;
}