栈与队列

  栈：栈是一种重要的线性结构，栈是线性表的一种具体形式。栈是一个后进先出的线性表，它要求只在表尾进行删除和插入操作，栈的表尾称为栈的栈顶（top），表头称为栈底（bottom）。

栈的插入操作叫进栈也称压栈，栈的删除操作叫出栈也称弹栈。

  队列：只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表（头删尾插）。只能在队首和队尾运算，且访问结点时依据先进先出的原则。

  栈和队列是2种常用的，重要的数据结构，栈和队列是限定插入和删除操作只能在表的端点进行的线性表

顺序栈

#include<stdio.h>
#include<stdlib.h>
#define size 100
#define stackextrasize 10
#define ElemType int
typedef struct {
ElemType *base;
ElemType *top;
int stacksize;
}stack;
stack* InitStack(stack *s){
s=(stack *)malloc(sizeof(stack));
s->base=(ElemType *)malloc(size*sizeof(ElemType));
if(!s->base){
exit(0);
}
s->top=s->base;
s->stacksize=size;
return s;
}
void Push(stack *s,ElemType e){
if(s->top-s->base==s->stacksize){
exit(0);
}
*s->top++=e;
}
void Pop(stack *s,ElemType *e){
if(s->top==s->base){
exit(0);
}
*e=*--s->top;
}
int main(){
stack *s;int i,e,n;
s=InitStack(s);
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&e);
Push(s,e);
}
for(i=0;i<n;i++){
Pop(s,&e);
printf("%d",e);
}
return 0;
}

链栈

#include<stdio.h>
#include<stdlib.h>
#define SElemType int
typedef struct Stacknode{
SElemType data;
struct Stacknode *next;
}Stacknode;
Stacknode* InitStack(Stacknode *S){
S=(Stacknode *)malloc(sizeof(Stacknode));
S->next=NULL;
//S=NULL;
return S;
}
int StackEmpty(Stacknode *S){
if(S==NULL)return 1;
else return 0;
}
Stacknode * Push(Stacknode *S,SElemType e){
Stacknode *p;
p=(Stacknode *)malloc(sizeof(Stacknode));
p->data=e;
p->next=S;
S=p;
return S;
}
Stacknode* Pop(Stacknode *S,SElemType *e){
if(S==NULL)
exit(0);
*e=S->data;
S=S->next;
return S;
}
int main(){
int i,n,e;Stacknode *S;
scanf("%d",&n);
S=InitStack(S);
for(i=0;i<n;i++){
scanf("%d",&e);
S=Push(S,e);

}
while(S->next){
printf("%d ",S->data);
S=S->next;
}
/*for(i=0;i<n;i++){
S=Pop(S,&e);
printf("%d",e);
}*/
return 0;
}

顺序队列

#include<stdio.h>
#include<stdlib.h>
#define MAXQSIZE 100
#define QElemType int
typedef struct{
QElemType *base;
int front;
int rear;
}SqQueue;
SqQueue* InitQueue(SqQueue *Q){
Q=(SqQueue *)malloc(sizeof(SqQueue));
Q->base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
if(!Q->base)exit(0);
Q->front=0;Q->rear=0;
return Q;
}
void EnQueue(SqQueue *Q,QElemType e){
if((Q->rear+1)%MAXQSIZE==Q->front)
exit(0);//队满
Q->base[Q->rear]=e;
Q->rear=(Q->rear+1)%MAXQSIZE;
}
void DeQueue(SqQueue *Q,QElemType *e){
if(Q->front==Q->rear)
exit(0);
*e=Q->base[Q->front];
Q->front=(Q->front+1)%MAXQSIZE;
}
int Queuelength(SqQueue *Q){
return((Q->rear-Q->front+MAXQSIZE)%MAXQSIZE);
}
int main(){
SqQueue *Q;int i,n,e;
Q=InitQueue(Q);
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&e);
EnQueue(Q,e);
}
printf("该顺序循环队列的长度为%d\n",Queuelength(Q));
for(i=0;i<n;i++){
DeQueue(Q,&e);
printf("%d ",e);
}
return 0;
}

链队

#include<stdio.h>
#include<stdlib.h>
#define MAXQSIZE 100
#define QElemType int
typedef struct Qnode{
QElemType data;
struct Qnode *next;
}Qnode;
typedef struct{
Qnode *front;
Qnode *rear;
}LinkQueue;
LinkQueue* InitQueue(LinkQueue *Q){
Q=(LinkQueue *)malloc(sizeof(LinkQueue));
Q->front=Q->rear=(Qnode*)malloc(sizeof(Qnode));
if(!Q->front)
exit(0);
Q->front->next=NULL;
Q->rear->next=NULL;
return Q;
}
void DestroyQueue(LinkQueue *Q){
Qnode *P;
while(Q->front){
P=Q->front->next;
free(Q->front);
Q->front=P;
}
}
void EnQueue(LinkQueue *Q,QElemType e){
Qnode *P;
P=(Qnode *)malloc(sizeof(Qnode));
if(!P)
exit(0);
P->data=e;
P->next=NULL;
Q->rear->next=P;
Q->rear=P;
}
void GoQueue(LinkQueue *Q,QElemType *e){
Qnode *P;
P=(Qnode *)malloc(sizeof(Qnode));
P=Q->front->next;
*e=P->data;
Q->front->next=P->next;
free(P);
}
int main(){
int i,n,e;
LinkQueue *Q;
Q=InitQueue(Q);
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&e);
EnQueue(Q,e);
}
for(i=0;i<n;i++){
GoQueue(Q,&e);
printf("%d ",e);
//printf("sasa");
}
return 0;
}