数据结构（24）队列--两个栈实现

 

单纯的用线性表或者单链表实现队列已经不足为奇，现在给大家介绍个有特色的，用两个栈实现队列。

 如图

   

这里介绍队列的常用操作：

l 创建队列

l 销毁队列

l 清空队列

l 入队

l 出队

l 返回队首元素

l 返回队的大小

代码总分为三个文件：

SQueue.h ： 放置功能函数的声明，以及表的声明 

SQueue.c ： 放置功能函数的定义，以及表的定义

Main.c     ： 主函数，使用功能函数完成各种需求，一般用作测试

整体结构图为：

这里详细说下入队操作，出队操作和返回队首元素操作：

 

入队操作：

如图：

  

出队操作：

如图：

 

返回队首元素：

如图：

         

OK! 上代码：

SQueue.h ：

 

 #ifndef _SQUEUE_H_
 #define _SQUEUE_H_

 typedef void SQueue;

 SQueue* SQueue_Create();

 void SQueue_Destroy(SQueue* queue);

 void SQueue_Clear(SQueue* queue);

 int SQueue_Append(SQueue* queue, void* item);

 void* SQueue_Retrieve(SQueue* queue);

 void* SQueue_Header(SQueue* queue);

 int SQueue_Length(SQueue* queue);

 #endif

 

SQueue.c ： 

 #include <stdio.h>
 #include <malloc.h>
 #include "LinkStack.h"
 #include "SQueue.h"

 typedef struct _tag_SQueue
 {
     LinkStack* inStack;
     LinkStack* outStack;
 }TSQueue;

 SQueue* SQueue_Create()
 {
     TSQueue* ret = (TSQueue*)malloc(sizeof(TSQueue));

     if(NULL != ret)
     {
         ret->inStack  = LinkStack_Create();
         ret->outStack = LinkStack_Create();

         if((NULL == ret->inStack) || (NULL == ret->outStack))
         {
             LinkStack_Destroy(ret->inStack);
             LinkStack_Destroy(ret->outStack);

             free(ret);
             ret = NULL;
         }
     }

     return ret;
 }

 void SQueue_Destroy(SQueue* queue)
 {
     SQueue_Clear(queue);

     free(queue);
 }

 void SQueue_Clear(SQueue* queue)
 {
     TSQueue* sQueue = (TSQueue*)queue;

     if(NULL != sQueue)
     {
         LinkStack_Clear(sQueue->inStack);
         LinkStack_Clear(sQueue->outStack);
     }
 }

 int SQueue_Append(SQueue* queue, void* item)
 {
     TSQueue* sQueue = (TSQueue*)queue;

     int ret = 0;

     if(NULL != sQueue)
     {
         ret = LinkStack_Push(sQueue->inStack, item);
     }

     return ret;
 }

 void* SQueue_Retrieve(SQueue* queue)
 {
     TSQueue* sQueue = (TSQueue*)queue;

     void* ret = NULL;

     if(NULL != sQueue)
     {
         if(0 == LinkStack_Size(sQueue->outStack))
         {
             while(0 < LinkStack_Size(sQueue->inStack))
             {
                 LinkStack_Push(sQueue->outStack, LinkStack_Pop(sQueue->inStack));
             }
         }

         ret = LinkStack_Pop(sQueue->outStack);
     }

     return ret;
 }

 void* SQueue_Header(SQueue* queue)
 {
     TSQueue* sQueue = (TSQueue*)queue;

     void* ret = NULL;

     if((NULL != sQueue) && (0 < SQueue_Length(queue)))
     {
         if(0 == LinkStack_Size(sQueue->outStack))
         {
             while(0 < LinkStack_Size(sQueue->inStack))
             {
                 LinkStack_Push(sQueue->outStack, LinkStack_Pop(sQueue->inStack));
             }
         }

         ret = LinkStack_Top(sQueue->outStack);
     }

     return ret;
 }

 int SQueue_Length(SQueue* queue)
 {
     TSQueue* sQueue = (TSQueue*)queue;

     int ret = -1;

     if(NULL != sQueue)
     {
         ret = LinkStack_Size(sQueue->inStack) +
               LinkStack_Size(sQueue->outStack);
     }

     return ret;
 }

 

Main.c     ：

 #include <stdio.h>
 #include <stdlib.h>
 #include "SQueue.h"

 int main(void)
 {
     SQueue* queue = SQueue_Create();

     int a[10];
     int i = 0;

     for(i=0; i<10; i++)
     {
         a[i] = i+1;

         SQueue_Append(queue, a+i);
     }
     printf("Length:  %d\n", SQueue_Length(queue));
     printf("Header:  %d\n", *(int*)SQueue_Header(queue));


     for(i=0; i<5; i++)
     {
         printf("Retrieve:  %d\n", *(int*)SQueue_Retrieve(queue));
     }

     printf("Header:  %d\n", *(int*)SQueue_Header(queue));
     printf("Length:  %d\n", SQueue_Length(queue));

     for(i=0; i<10; i++)
     {
         a[i] = i+1;

         SQueue_Append(queue, a+i);
     }

     while(SQueue_Length(queue) > 0)
     {
         printf("Retrieve:  %d\n", *(int*)SQueue_Retrieve(queue));
     }

     SQueue_Destroy(queue);

     return 0;
 }