栈队列：使用两个栈实现一个队列

栈队列：使用两个栈实现一个队列

思路：
    1.入队列，是将数据放入栈1
    2.出队列，是将栈1数据出栈后依次存入栈2，然后栈2进行出栈
    这样就模拟了队列的 先进先出 思想

1.Stack.h

#pragma once
#include <assert.h>
#include <stdlib.h>
#include <String.h>

// 栈实现

typedef  int SDataType;

#define MAX_SIZE (100)

//栈结构定义：数组 栈顶
typedef struct Stack {
    SDataType array[MAX_SIZE];
    int       top;  // 含义和顺序表的size一样                  
}   Stack;         // 1.表示有效数据个数    2.top 下标表示当前可用位置 

//初始化
void StackInit(Stack *pS) {
    assert(pS != NULL);

    pS->top = 0;
}

// 入（压）栈
void StackPush(Stack *pS, SDataType data) {
    assert(pS != NULL);
    assert(pS->top < MAX_SIZE);

    pS->array[pS->top++] = data;
}

// 出栈
void StackPop(Stack *pS) {
    assert(pS != NULL);
    assert(pS->top > 0);

    pS->top--;
}

// 返回栈顶元素,
SDataType StackTop(Stack *pS) {
    assert(pS != NULL);
    assert(pS->top > 0);

    return pS->array[pS->top - 1];
}

// 判断栈是否为空
// 1 表示空， 0 表示非空
int StackIsEmpty(Stack *pS) {
    return pS->top == 0 ? 1 : 0;
}

// 返回栈数据个数
int StackSize(Stack *pS) {
    return pS->top;
}

// 栈拷贝
void StackCopy(Stack *pDest, Stack *pSrc) {
    pDest->top = pSrc->top;
    memcpy(pDest->array, pSrc->array, sizeof(SDataType) * pSrc->top);
}

void TestStack() {
    Stack stack;
    StackInit(&stack);

    StackPush(&stack, 9);
    StackPush(&stack, 5);
    StackPush(&stack, 7);
    StackPush(&stack, 3);

    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);

}

2.SQueue.h

#pragma once

#include "Stack.h"
#include <stdio.h>
/*
    栈队列：使用两个栈实现一个队列

    思路：
        1.入队列，是将数据放入栈1
        2.出队列，是将栈1数据出栈后依次存入栈2，然后栈2进行出栈
        这样就模拟了队列的 先进先出 思想
*/

// 栈队列结构定义
typedef struct SQueue {
    Stack stack1; // 入数据的栈
    Stack satck2; // 出数据的栈
}   SQueue;

// 栈队列初始化：也就是对队列里面的两个栈进行初始化
void SQueueInit(SQueue *pSQ)
{
    Stack *p1, *p2;
    p1 = &(pSQ->stack1);
    p2 = &(pSQ->satck2);

    StackInit(p1);
    StackInit(p2);
}

// 入队列
void SQueuePush(SQueue *pSQ, SDataType data)
{
    Stack *p1, *p2;
    p1 = &(pSQ->stack1);
    p2 = &(pSQ->satck2);

    StackPush(p1, data);
}

// 出队列
void SQueuePop(SQueue *pSQ)
{
    Stack *p1, *p2;
    p1 = &(pSQ->stack1);
    p2 = &(pSQ->satck2);
    SDataType data;

    /* 若栈2为空，而栈1不为空，则将栈1数据取出来保存在data中，
       栈1出栈，将data入栈2，直到栈1为空
    */
    if (StackIsEmpty(p2)) {
        while (!StackIsEmpty(p1)) {
            data = StackTop(p1);
            StackPop(p1);
            StackPush(p2, data);
        }
    }
    //栈2出栈
    StackPop(p2);
}

// 返回队列首元素值
SDataType SQueueFront(SQueue *pSQ)
{
    Stack *p1, *p2;
    p1 = &(pSQ->stack1);
    p2 = &(pSQ->satck2);
    SDataType data;

    if (StackIsEmpty(p2)) {
        while (!StackIsEmpty(p1)) {
            data = StackTop(p1);
            StackPop(p1);
            StackPush(p2, data);
        }
    }

    return StackTop(p2);
}

void TestSQueue()
{
    SQueue sQueue;

    SQueueInit(&sQueue);

    SQueuePush(&sQueue, 9);
    SQueuePush(&sQueue, 5);
    SQueuePush(&sQueue, 2);
    SQueuePush(&sQueue, 7);

    SQueuePop(&sQueue);
    SQueuePush(&sQueue, 8);

    // 此时栈2不为空，不会将栈1的数字8放入栈2
    printf("%d\n", SQueueFront(&sQueue)); // 5

    system("pause");
}

3.Main.c

#include "SQueue.h"

int main()
{
    //TestStack();
    TestSQueue();

    return 0;
}