《栈和队列（代码文件）》

1.顺序栈

1)  声明类型

#define MaxSize 100

typedef char ElemType;

typedef struct

{

ElemType data[MaxSize];

int top;                    //栈顶指针

} SqStack;

2)  初始化栈

void InitStack(SqStack *&s)      //初始化栈S

{    s=(SqStack*)malloc(sizeof(SqStack));

s->top=-1;                  //栈顶指针置为-1

}

3)  销毁栈

void DestroyStack(SqStack *&s)   //销毁栈s

{

free(s);

}

4)  判断栈空

bool StackEmpty(SqStack *s)      //判断栈空

{

return(s->top==-1);

}

5)  进栈

bool Push(SqStack *&s,ElemType e)    //进栈

{    if(s->top==MaxSize-1)  //栈满的情况，即栈上溢出

     return false;

s->top++;               //栈顶指针增1

s->data[s->top]=e;      //元素e放在栈顶指针处

return true;

}

6)  出栈

bool Pop(SqStack *&s,ElemType &e)    //出栈

{    if (s->top==-1)     //栈为空的情况，即栈下溢出

     return false;

e=s->data[s->top];  //取栈顶指针元素的元素

s->top--;           //栈顶指针减1

return true;

}

7)  取栈顶元素

bool GetTop(SqStack *s,ElemType &e)      //取栈顶元素

{    if (s->top==-1)     //栈为空的情况，即栈下溢出

     return false;

e=s->data[s->top];  //取栈顶指针元素的元素

return true;

}

8)  取长度

int List(SqStack *s)

{    return(s->top+1);   }

 

2.链栈

1）声明类型

typedef char ElemType;

typedef struct linknode

{

ElemType data;              //数据域

struct linknode *next;      //指针域

} LiStack;

2）初始化

void InitStack(LiStack *&s)      //初始化栈s

{    s=(LiStack*)malloc(sizeof(LiStack));

s->next=NULL;

}

3）销毁栈

void DestroyStack(LiStack *&s)   //销毁栈

{    LiStack *p=s,*q=s->next;

while (q!=NULL)

{   free(p);

     p=q;

     q=p->next;

}

free(p);    //此时p指向尾节点,释放其空间

}

4）判断是否为空

bool StackEmpty(LiStack *s)  //判断栈是否为空

{

return(s->next==NULL);

}

5）进栈

void Push(LiStack *&s,ElemType e)    //进栈

{    LiStack *p;

p=(LiStack*)malloc(sizeof(LiStack));

p->data=e;              //新建元素e对应的节点*p

p->next=s->next;        //插入*p节点作为开始节点

s->next=p;

}

6）出栈

bool Pop(LiStack *&s,ElemType &e)    //出栈

{    LiStack *p;

if (s->next==NULL)      //栈空的情况

     return false;

p=s->next;              //p指向开始节点

e=p->data;

s->next=p->next;        //删除*p节点

free(p);                //释放*p节点

return true;

}

7）去栈顶元素

bool GetTop(LiStack *s,ElemType &e)  //取栈顶元素

{    if (s->next==NULL)      //栈空的情况

     return false;

e=s->next->data;

return true;

}

8）求栈的长度

voidStackLength(LiStack  *s)
{
 int i=0;
 LiStack *p;
 p=s->next;
 while(p!=NULL)
 {
  i++;
  p=p->next;
 }
 printf("目前此栈的长度为：%d\n",i);
}

3.顺序环形队列

（1）声明

#define MaxSize 5

typedef char ElemType;

typedef struct

{

    ElemTypedata[MaxSize];

    intfront,rear;     //队首和队尾指针

} SqQueue;

（2）初始化列表

void InitQueue(SqQueue *&q) //初始化队列

{   q=(SqQueue*)malloc (sizeof(SqQueue));

    q->front=q->rear=0;

}

（3）销毁队列

void DestroyQueue(SqQueue *&q)  //销毁队列

{

    free(q);

}

（4）判断队列空

bool QueueEmpty(SqQueue *q) //判断队列空

{

    return(q->front==q->rear);

}

（5）进队

bool enQueue(SqQueue *&q,ElemType e)    //进队

{

    if ((q->rear+1)%MaxSize==q->front)  //队满上溢出

        returnfalse;

    q->rear=(q->rear+1)%MaxSize;//将指针rear加1然后输入e

    q->data[q->rear]=e;

    return true;

}

（6）出队

bool deQueue(SqQueue *&q,ElemType &e)   //出队

{

    if(q->front==q->rear)      //队空下溢出

        returnfalse;

    q->front=(q->front+1)%MaxSize;//将指针front加1然后输出

    e=q->data[q->front];

    return true;

}

（7）求队列的长度 

int QueueLength(SqQueue *q)

{ return q->rear-q->front; } 

（8）显示队列中元素

void DispQueue(SqQueue *q) 

{ 

    int i; 

    for(i=q->front+1;i<=q->rear;i++) 

        printf("%c",q->data[i]); 

    printf("\n"); 

}

4.链队

（0）声明

typedef char ElemType;

typedef struct qnode

{

    ElemTypedata;

    struct qnode*next;

} QNode;

typedef struct

{

    QNode*front;

    QNode *rear;

} LiQueue;

（1）初始化队列

void InitQueue(LiQueue *&q) //初始化队列

{   q=(LiQueue *)malloc(sizeof(LiQueue));

    q->front=q->rear=NULL;

}

（2）销毁队列

void DestroyQueue(LiQueue *&q)  //销毁队列

{   QNode*p=q->front,*r;   //p指向队头数据节点

    if (p!=NULL)            //释放数据节点占用空间

    {   r=p->next;

        while(r!=NULL)

        {   free(p);

            p=r;r=p->next;

        }

    }

    free(p);

    free(q);                //释放链队节点占用空间

}

（3）判断队列是否为空

bool QueueEmpty(LiQueue *q) //判断队列是否为空

{

    return(q->rear==NULL);

}

（4）进队

void enQueue(LiQueue *&q,ElemType e)    //进队

{   QNode *p;

    p=(QNode*)malloc(sizeof(QNode));

    p->data=e;

    p->next=NULL;

    if(q->rear==NULL)      //若链队为空,则新节点是队首节点又是队尾节点

        q->front=q->rear=p;

    else

    {   q->rear->next=p;    //将*p节点链到队尾,并将rear指向它

        q->rear=p;

    }

}

（5）出队

bool deQueue(LiQueue *&q,ElemType &e)   //出队

{   QNode *t;

    if(q->rear==NULL)      //队列为空

        returnfalse;

    t=q->front;             //t指向第一个数据节点

    if(q->front==q->rear)  //队列中只有一个节点时

        q->front=q->rear=NULL;

    else                    //队列中有多个节点时

        q->front=q->front->next;//将指针front移到下一位上

    e=t->data;

    free(t);

    return true;

}

（6）返回队列中数据元素个数

int QueueLength(LiQueue *q) 

{   int n=0;

    QNode *p=q->front;

    while (p!=NULL)

    {

        n++;

        p=p->next;

    }

    return(n);

}