栈和队列的实现

栈和队列是线性的数据结构，从数据结构的角度来看，栈和队列是两种特殊的线性表。
栈——“后进先出”，队列——“先进现出”。它们是操作受限的线性表。

栈的概念及操作
栈是限定仅在表的一端进行插入和删除运算的线性表。允许插入和删除的一端称为栈顶（top）。不允许插入和删除的一端称为栈底（bottom）。表中没有元素时称为空栈。

栈的存储结构及操作实现

与线性表类似，栈有两种存储表示方式。顺序存储结构表示的栈称为顺序表，链式存储结构表示的栈称为链栈。

顺序栈
#define maxsize
typedef struct
{
 datatype data[maxsize];
 int top;
 int stacksize;
} seqstack;
seqstack *s

1、置空栈
void INITSTACK(seqstack *s)
{
 s.data=(datatype *)malloc(maxsize*sizeof(datatype));
 s->top=-1;
 s->stacksize=maxsize; 
}
2、判空栈
int EMPTYSTACK(seqstack *s,)
{
 if(s->top>0)
  return 0;
 else 
  return 1;
}
3、入栈
void PUSH(seqstack *s,datatype x)
{
 if(s->top==maxsize-1)
  printf("OverFlow/n");
 else
 {
  s->top++;
  s->data[s->top]=x;
 }
}
4、出栈
void POP(seqstack *s,datatype &x)
{
 if(EMPTYSTACK(s))
  printf("UnderFlow stack is empty/n");
 else
 { 
  x=s->data[s->top];
  s->top--;
 }   
}
5、取栈顶元素
void GETTOP(seqstack s,datatype &x)
{
 if(EMPTYSTACK(s))
  printf("stack is empty/n");
 else
 {
  x=s->data[s->top]; 
 }
}

链栈
typedef struct stacknode
{
 dataype data;
 struct stacknode *next;
} linkstack;
linkstack *top;
1、链栈初始化
void INITSTACK(linkstack *top)
{
 top=NULL;
}
2、判空栈
int EMPTYSTACK(linkstack *top)
{
 if(top!=NULL)
  return 0;
 else
  return 1;
}
3、入栈
void PUSH(linkstack *top,datatype x)
{
 linkstack *p;
 p=malloc(sizeof(linkstack));
 p->data=x;
 p->next=NULL;
 top->next=p;
 top=p;
}
4、出栈
void POP(linkstack *top,datatype &x)
{
 linkstack *p;
 if(EMPTYSTACK(top))
  printf("UnderFlow/n");
 else
 {
  p=top;
  x=top->data;
  top=top->next;
  free(p); 
 }
}
5、取栈顶元素
void GETTOP(linkstack *top,datatype &x)
{
 if(EMPTYSTACK(top))
  printf("UnderFlow,stack is empty/n");
 else
  x=top->data;
}

队列的概念及操作
队列（queue）是限定只能在表的一端进行插入，且只能在另一端进行删除的线性表。在表中允许删除的一端称为队首（front）；允许插入的一端队列（rear）。

顺序队列
#define max 100
typedef struct
{
 datatype data[max];
 int front;
 int rear;
} sequeue;
sequeue * sq;
由于会产生假溢出，使用循环队列可以解决这个问题。

循环队列的操作
1、初始化
void INITQUEUE(sequeue *sq,int max=100)
{
 sq->data=(datatype *)malloc((max+1)*sizeof(datatype));
 sq->front=0;
 sq->rear=0; 
}
2、判对空
int EMPTYQUEUE(sequeue sq)
{
 if(s->front==s->rear)
  return 1;
 else
  return 0;
}
3、入队
void ENQUEUE(sequeue *sq,datatype x)
{
 if((s->rear+1)%max==sq->front)
  printf("OVERFLOW");
 else
 {
  sq->data[sq->rear]=x;
  sq->rear++;
 }
}
4、出队
void DEQUEUE(sequeue *sq,datatype &x)
{
 if(EMPTYQUEUE)
  printf("UnderFlow");
 else
 {
  x=sq->data[sq->front];
  sq->front--;
 } 
}
5、取队头元素
void GETFRONT(sequeue *sq,datatype &x)
{
 if(EMPTYQUEUE)
  printf("UnderFlow queue is empty");
 else
 {
  x=sq->datap[sq->front];
 }
}

链队列
typedef struct queuenode
{
 datatype data;
 struct queuenode *next;
} queuenode;
typedef struct linkqueue
{
 queuenode *front,*rear;
} linkqueue;
linkqueue *sq;
1、置空队列
void INITQUEUE(linkqueue *sq)
{
 sq->front=malloc(sizeof(queuenode));
 sq->rear=sq->front=NULL;
}
2、判队空
int EMPTYQUEUE(linkqueue *sq)
{
 if(sq->front==sq->rear)
  return 1;
 else
  return 0;
}
3、入队
void ENQUEUE(linkqueue *sq,datatype x)
{
 queuenode *p;
 p=malloc(sizeof(queuenode));
 p->data=x;
 p->next=NULL;
 sq->rear->next=p;
 sq->rear=p;
}
4、出队
void DEQUEUE(linkqueue *sq,datatype &x)
{
 linkqueue *p;
 if(EMPTYQUEUE)
  printf("UnderFlow/n");
 else
 {
  p=sq->front;
  x=p->data;
  sq->front=p->next;
  free(p);
 }
}
5、取队头
void GETFRONT(linkqueue *sq,datatype &x)
{
 linkqueue *p;
 if(EMPTYQUEUE)
  printf("UnderFlow/n");
 else
 {
  x=sq->front->data;
 }
}