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

本文主要是介绍（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;  
 }  