（C语言版）栈和队列（二）——实现顺序存储栈和顺序存储队列的相关操作

http://blog.csdn.net/fisherwan/article/details/21479649

 栈和队列都有两种实现方式，一种在之前已经写过了，是链式存储形式，另一种是顺序存储形式。也就是这里所写的用数组的形式实现，和链式存储形式相比，有几个不同的地方。

顺序存储的方式，必须确定栈和队列的大小，也就是要确定数组的大小。而链式储存是动态分配的，根据需要来增减。
顺序存储的方式有溢出的现象，由于是数组存储，所以超出数组下标的时候就溢出了。

        下面上代码：

SequentialStack.h 顺序存储栈头文件

[cpp] view
plain copy

#ifndef _SEQUENTIALSTACK_H_H  

#define _SEQUENTIALSTACK_H_H  

  

typedef int SStackEle;  

const int MAXSTACK = 20;  

  

typedef struct SSTACK  

{  

    SStackEle arrele[MAXSTACK];  

    SStackEle top;  

}SStack;  

  

//初始化顺序栈  

void InitSStack(SStack &s);  

  

//压入栈  

void PushSStack(SStack &s, SStackEle ele);  

  

//出栈  

void PopSStack(SStack &s, SStackEle &ele);  

  

//判断栈是否为空  

bool IsemptySStack(SStack s);  

  

//得到栈顶元素  

SStackEle GetTopSStack(SStack s);  

  

#endif  

SequentialQueue.h
顺序存储队列头文件

[cpp] view
plain copy

#ifndef _SEQUENTIALQUEUE_H_H  

#define _SEQUENTIALQUEUE_H_H  

  

typedef int SQueueEle;  

const int MAXQUEUE = 10;  

  

typedef struct SQUEUE  

{  

    SQueueEle arrele[MAXQUEUE];  

    SQueueEle front, rear;  

}SQueue;  

  

//初始化顺序队列  

void InitSQueue(SQueue &q);  

  

//入队  

void EnSQueue(SQueue &q, SQueueEle ele);  

  

//出队  

void DeSQueue(SQueue &q, SQueueEle &ele);  

  

//判断队列是否为空  

bool IsemptySQueue(SQueue q);  

  

//获得队头元素  

SQueueEle GetFrontSQueue(SQueue q);  

  

#endif  

SequentialStack.cpp
顺序存储栈源文件

[cpp] view
plain copy

#include "SequentialStack.h"  

#include <stdio.h>  

  

//初始化顺序栈  

void InitSStack(SStack &s)  

{  

    s.top = -1;  

}  

  

//压入栈  

void PushSStack(SStack &s, SStackEle ele)  

{  

    s.top++;  

    if (s.top < MAXSTACK)  

        s.arrele[s.top] = ele;  

    else  

        printf("栈满，不能进行压入操作！\n");  

}  

  

//出栈  

void PopSStack(SStack &s, SStackEle &ele)  

{  

    if (s.top < 0)  

        printf("栈空，不能进行出栈操作！\n");  

    else  

    {  

        ele = s.arrele[s.top];  

        s.top--;  

    }  

}  

  

//判断顺序栈是否为空  

bool IsemptySStack(SStack s)  

{  

    if (s.top = -1)  

        return true;  

    else  

        return false;  

}  

  

//获得栈顶元素值  

SStackEle GetTopSStack(SStack s)  

{  

    if (s.top < 0)  

        printf("栈空，不能获得栈顶元素值！\n");  

    else  

        return s.arrele[s.top];  

}  

SequentialQueue.cpp
顺序存储队列源文件

[cpp] view
plain copy

#include "SequentialQueue.h"  

#include <stdio.h>  

  

//初始化顺序队列  

void InitSQueue(SQueue &q)  

{  

    q.front = q.rear = -1;  

}  

  

//入队列  

void EnSQueue(SQueue &q, SQueueEle ele)  

{  

    if (q.rear >= MAXQUEUE)  

        printf("队列满，不能进行入队操作！\n");  

    else  

        q.arrele[++q.rear] = ele;  

}  

  

//出队列  

void DeSQueue(SQueue &q, SQueueEle &ele)  

{  

    if (IsemptySQueue(q))  

        printf("队列空，不能进行出队操作！\n");  

    else  

        ele = q.arrele[++q.front];  

}  

  

//判断队列是否为空  

bool IsemptySQueue(SQueue q)  

{  

    if (q.front == q.rear)  

        return true;  

    else  

        return false;  

}  

  

//获得队头元素值  

SQueueEle GetFrontSQueue(SQueue q)  

{  

    if (IsemptySQueue(q))  

        printf("队空，不能获得队头元素值！\n");  

    else  

        return q.arrele[q.front + 1];  

}  

main.cpp
测试程序源文件

[cpp] view
plain copy

#include <stdio.h>  

#include "SequentialStack.h"  

#include "SequentialQueue.h"  

  

int main()  

{  

    /*顺序栈测试代码*/  

    int ele;  

    SStack s;  

    InitSStack(s);  

  

    PushSStack(s, 0);  

    PushSStack(s, 1);  

    PushSStack(s, 2);  

  

    printf("栈顶元素值为：%d\n", GetTopSStack(s));  

  

    PopSStack(s, ele);  

    printf("出栈第1个元素是：%d\n", ele);  

  

    printf("栈顶元素值为：%d\n", GetTopSStack(s));  

  

    PopSStack(s, ele);  

    printf("出栈第2个元素是：%d\n", ele);  

    PopSStack(s, ele);  

    printf("出栈第3个元素是：%d\n", ele);  

  

    PopSStack(s, ele);  

  

    if (IsemptySStack(s))  

        printf("栈为空！\n");  

    putchar('\n');  

    /*顺序队列测试代码*/  

    SQueue q;  

    InitSQueue(q);  

  

    EnSQueue(q, 0);  

    EnSQueue(q, 1);  

    EnSQueue(q, 2);  

  

    printf("队头元素值为：%d\n", GetFrontSQueue(q));  

  

    DeSQueue(q, ele);  

    printf("出队第1个元素是：%d\n", ele);  

  

    printf("队头元素值为：%d\n", GetFrontSQueue(q));  

  

    DeSQueue(q, ele);  

    printf("出队第2个元素是：%d\n", ele);  

    DeSQueue(q, ele);  

    printf("出队第3个元素是：%d\n", ele);  

  

    DeSQueue(q, ele);  

  

    if (IsemptySQueue(q))  

        printf("队列为空！\n");  

  

    return 0;  

}  

下面附测试结果图一张：



PS：个人测试没有问题，如果大家发现问题请及时联系，不胜感激！