【LeetCode】剑指 Offer 09. 用两个栈实现队列

【题目描述】

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：

1 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof

【解题思路】

用两个栈实现队列：

• 栈无法实现队列功能： 栈底元素（对应队首元素）无法直接删除，需要将上方所有元素出栈。
• 双栈可实现列表倒序： 设有含三个元素的栈 A = [1,2,3] 和空栈 B = []。若循环执行 A 元素出栈并添加入栈 B ，直到栈 A 为空，则 A = [] , B = [3,2,1]，即 栈 B 元素实现栈 A 元素倒序 。
• 利用栈 B 删除队首元素： 倒序后，B 执行出栈则相当于删除了 A 的栈底元素，即对应队首元素。

【提交代码】

typedef struct st_stack{
    int size;
    int *data;
    int top;    
}T_Stack;

typedef struct {
    T_Stack *s1;
    T_Stack *s2;
} CQueue;


int StackInit( T_Stack *ptStack, int *data, int size)
{
    ptStack->size = size;
    ptStack->data = data;
    ptStack->top = 0;

    return 0;
}

int StackPush( T_Stack *ptStack, int data )
{
    if( ptStack->top == ptStack->size )
    {
        return -1;
    }
    
    ptStack->data[ptStack->top++] = data;

    return 0;
}

int StackPop( T_Stack *ptStack, int *data )
{
    if( ptStack->top == 0 )
    {
        return -1;
    }

    *data = ptStack->data[--ptStack->top];

    return 0;
}

int StackTop( T_Stack *ptStack, int *data )
{
    if( ptStack->top == 0 )
    {
        return -1;
    }

    *data = ptStack->data[ptStack->top - 1];

    return 0;
}

int StackIsEmpty( T_Stack *ptStack )
{
    return ( ptStack->top == 0 );
}

int StackIsFull( T_Stack *ptStack )
{
    return ( ptStack->top == ptStack->size );
}

#define QUEUE_SIZE_MAX      ( 10000 )

CQueue* cQueueCreate() {
    int *data1;
    int *data2;
    T_Stack *s1;
    T_Stack *s2;
    CQueue *queue;

    data1 = (int *)malloc( sizeof(int) * QUEUE_SIZE_MAX );
    data2 = (int *)malloc( sizeof(int) * QUEUE_SIZE_MAX );

    s1 = (T_Stack *)malloc( sizeof(T_Stack));
    s2 = (T_Stack *)malloc( sizeof(T_Stack));

    StackInit( s1, data1, QUEUE_SIZE_MAX );
    StackInit( s2, data2, QUEUE_SIZE_MAX );

    queue = (CQueue *)malloc( sizeof(CQueue) );

    queue->s1 = s1;
    queue->s2 = s2;

    return queue;
}

int cQueueAppendTail(CQueue* obj, int value) {
    if( StackIsFull( obj->s1) ) 
    {
        return -1;
    }

    if( StackPush( obj->s1, value ) != 0 )
    {
        return -1;
    }

    return 0;
}

int cQueueDeleteHead(CQueue* obj) {
    int tmp;

    // 1.当B不为空，则B中仍有已完成倒叙的元素，因此直接返回B的栈顶元素
    if( !StackIsEmpty( obj->s2 ) )
    {
        if( StackPop( obj->s2, &tmp ) != 0)
        {
            return -1;
        }

        return tmp;
    }

    // 2.当A也为空，则两个栈都为空，无元素，因此返回-1
    if( StackIsEmpty( obj->s1 ) )
    {
        return -1;
    }

    // 3.将A元素全部转移至栈B中，实现元素倒叙，并返回栈B的栈顶元素
    while( !StackIsEmpty( obj->s1) && !StackIsFull( obj->s2 ) )
    {
        StackPop( obj->s1, &tmp );
        StackPush( obj->s2, tmp );
    }

    if( !StackIsEmpty( obj->s1) ) // 如果A没有完全转移，则还是错误的
    {
        return -1;
    }

    StackPop( obj->s2, &tmp );

    return tmp;
}

void cQueueFree(CQueue* obj) {
    free(obj->s1->data);
    free(obj->s2->data);
    free(obj->s1);
    free(obj->s2);
    free(obj);
}

/**
 * Your CQueue struct will be instantiated and called as such:
 * CQueue* obj = cQueueCreate();
 * cQueueAppendTail(obj, value);
 
 * int param_2 = cQueueDeleteHead(obj);
 
 * cQueueFree(obj);
*/