队列的特殊实现方式

特别实现方案：
实现思路：
准备两个栈用于实现队列：inStack和outStack；
当有新元素入队时： ：将其压入 将其压入inStack中；
当需要出队时：
• 当outStack为空时：
1. 将inStack中的元素逐一弹出并压入outStack中；
2. 将outStack的栈顶元素弹出；
• 当outStack不为空时：

– 直接将outStack的栈顶元素弹出；

图例为特例，经分析，一般也可以适用；

#include <stdio.h>//本例包含栈，链表，代码复用思想，且实现过程简单高效有趣
#include <malloc.h>
#include "LinkStack.h"
#include "SQueue.h"


typedef struct _tag_SQueue//结构体表示特别队列
{
    LinkStack* inStack;
    LinkStack* outStack;
} TSQueue;


SQueue* SQueue_Create() // O(1)
{
    TSQueue* ret = (TSQueue*)malloc(sizeof(TSQueue));//从堆空间里面申请刚刚定义的结构体
    
    if( ret != NULL )//申请成功
    {
        ret->inStack = LinkStack_Create();
        ret->outStack = LinkStack_Create();
        
        if( (ret->inStack == NULL) || (ret->outStack == NULL) )//检测队列创建是否成功
        {
            LinkStack_Destroy(ret->inStack);
            LinkStack_Destroy(ret->outStack);
            
            free(ret);
            
            ret = NULL;
        }
    }
    
    return ret;
}


void SQueue_Destroy(SQueue* queue) // O(n)
{
    SQueue_Clear(queue);
    free(queue);
}


void SQueue_Clear(SQueue* queue) // O(n)
{
    TSQueue* sQueue = (TSQueue*)queue;
    
    if( sQueue != NULL )
    {
        LinkStack_Clear(sQueue->inStack);
        LinkStack_Clear(sQueue->outStack);
    }
}


int SQueue_Append(SQueue* queue, void* item) // O(1)//入队列
{
    TSQueue* sQueue = (TSQueue*)queue;
    
    if( sQueue != NULL )
    {
        LinkStack_Push(sQueue->inStack, item);
    }
}


void* SQueue_Retrieve(SQueue* queue) // 平均时间复杂度，即综合最好情况和最坏情况考虑O(1)
//出队列
{
    TSQueue* sQueue = (TSQueue*)queue;
    void* ret = NULL;
    
    if( sQueue != NULL )
    {
        if( LinkStack_Size(sQueue->outStack) == 0 )//outstack是否为空
        {
            while( LinkStack_Size(sQueue->inStack) > 0 )
   {
                LinkStack_Push(sQueue->outStack, LinkStack_Pop(sQueue->inStack));//元素从instack移动到outstack
            
            }
        }
        
        ret = LinkStack_Pop(sQueue->outStack);//出队列
    }
    
    return ret;
}


void* SQueue_Header(SQueue* queue) // O(1)
{
    TSQueue* sQueue = (TSQueue*)queue;
    void* ret = NULL;
    
    if( sQueue != NULL )
    {
        if( LinkStack_Size(sQueue->outStack) == 0 )
        {
            while( LinkStack_Size(sQueue->inStack) > 0 )
            {
                LinkStack_Push(sQueue->outStack, LinkStack_Pop(sQueue->inStack));
            }
        }
        
        ret = LinkStack_Top(sQueue->outStack);//第一个元素，Top
    }
    
    return ret;
}


int SQueue_Length(SQueue* queue) // O(1)两个栈大小之和
{
    TSQueue* sQueue = (TSQueue*)queue;
    int ret = -1;
    
    if( sQueue != NULL )
    {
        ret = LinkStack_Size(sQueue->inStack) + LinkStack_Size(sQueue->outStack);
    }
    
    return ret;
}

 组合使用两个栈的“后进先出”可以实现队列的“先进先出”；
两个栈实现队列的方法复用栈数据结构， 实现过程简单且高效；
两个栈实现的队列其操作的时间复杂度能够达到O(1)；