【数据结构】用两个栈实现队列

用两个栈实现队列：

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

代码实现：

typedef struct st_queue {
    T_Stack *s1;
    T_Stack *s2;
}T_Queue; 

int QueueInit( T_Queue *queue, T_Stack *s1, T_Stack *s2 )
{
    queue->s1 = s1;
    queue->s2 = s2;
    return 0;
}

int QueueAppend( T_Queue *queue, int val )
{
    int tmp;

#if 0
    if( StackIsFull( queue->s1) ) // StackA满，如果StackB不是空的话，则不能把A转移到B，则认为队列已经满了；
    {
        if( !StackIsEmpty( queue->s2 ) )
        {
            return -1;
        }

        // B没满，A没空，则不断地把A转到B
        while( !StackIsFull( queue->s2 ) && !StackIsEmpty( queue->s1 ))
        {
            if( StackPop( queue->s1, &tmp ) != 0 )
            {
                return -2;
            }
            StackPush( queue->s2, tmp );
        }
    }
#endif

    if( StackIsFull( queue->s1) ) 
    {
        return -3;
    }

    if( StackPush( queue->s1, val ) != 0 )
    {
        return -4;
    }

    return 0;
}

int QueueDelete( T_Queue *queue, int *val )
{
    int tmp;

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

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

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

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

    StackPop( queue->s2, &tmp );

    *val = tmp;

    return 0;
}

#define MAX_SIZE        ( 100 )

int test_stack_02( void )
{
    int *data1;
    int *data2;
    T_Stack *s1;
    T_Stack *s2;
    T_Queue *queue;
    int i;
    int ret;
    int val;

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

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

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

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

    QueueInit( queue, s1, s2 );

    for( i = 0; i < MAX_SIZE; i++ )
    {
        ret = QueueAppend( queue, i );
        printf("QueueAppend(%d), ret:%d
", i, ret);
    }

    for( i = 0; i < MAX_SIZE; i++ )
    {
        ret = QueueDelete( queue, &val );
        printf("QueueDelete(%d), ret:%d, val:%d
", i, ret, val);
    }

    free( data1 );
    free( data2 );
    free( s1 );
    free( s2 );
    free( queue );

    return 0;
}

参考引用：

https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/solution/mian-shi-ti-09-yong-liang-ge-zhan-shi-xian-dui-l-2/