力扣算法题——图书整理（C语言题解）

本文链接：https://blog.csdn.net/m0_74102727/article/details/134901970

题目描述

读者来到图书馆排队借还书，图书管理员使用两个书车来完成整理借还书的任务。书车中的书从下往上叠加存放，图书管理员每次只能拿取书车顶部的书。排队的读者会有两种操作：

push(bookID)：把借阅的书籍还到图书馆。
pop()：从图书馆中借出书籍。

为了保持图书的顺序，图书管理员每次取出供读者借阅的书籍是最早归还到图书馆的书籍。你需要返回 每次读者借出书的值 。

如果没有归还的书可以取出，返回 -1 。

示例 1：

输入：
["BookQueue", "push", "push", "pop"]
[[], [1], [2], []]
输出：[null,null,null,1]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.pop(); // return 1, queue is [2]

提示：

1 <= bookID <= 10000
最多会对 push、pop 进行 10000 次调用

题目解释

题目描述看完还是云里雾里的吗？别急，我也是。

首先这道题你不需要写主函数，也不需要考虑他是怎么调用的函数，用的scanf还是什么东西，无所谓。你要做的只是把目之所及的几个函数完善，你还可以添几个函数辅助完成这道题。

接下来用几个例子理解一下这道题是什么意思：

["CQueue","appendTail","deleteHead","deleteHead"] 框框里是要执行的方法，从左到右执行，不用管框框里这些东西要怎么输入。

[[],[3],[],[]]对应上面的方法，是上面方法的参数。CQueue和deleteHead方法不需要指定数字，只有添加才需要指定数字

1.创建队列，返回值为null

2.将3压入栈，返回值为null

3.将栈底的元素删除，也就是消息队列中先进来的元素，所以是deleteHead，返回该元素的数值，所以为3

4.继续删除栈底的元素，但是没有元素了，所以返回-1

所以就有了下面的输出输出：[null,null,3,-1]

示例 2： ["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]

[[],[],[5],[2],[],[]]

1.创建队列，返回值为null

2.删除栈底的元素，但是没有元素，所以返回-1

3.把5压入栈，返回null

4.把2压入栈，返回null

5.删除栈底的一个元素，也就是消息队列中先进来的元素，所以是deleteHead，就是最先进来的5，返回值为5，

6.删除栈底的一个元素，就是后进来的2，返回值为2，

所以就有了下面的输出

输出：[null,-1,null,null,5,2]

有没有发现先进来的数字，首先显示出来了，但是题目中说要使用栈，栈是先进后出的，使用栈来实现先进先出，在这里使用两个栈就好了，从一个进来再到另一个栈，这样顺序就是先进先出了。题目的主旨写在第一句，就是，使用两个栈实现一个队列。

代码实现：

思路

我创建两个栈，将一个栈当作输入栈，用于压入 appendTail 传入的数据；另一个栈当作输出栈，用于 deleteHead 操作。

每次 deleteHead 时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。

typedef struct {
    int * stk;
    int stkSize;
    int stkCapacity;
}Stack;

int stackTop(Stack* obj) {
    return obj->stk[obj->stkSize - 1];
}

void stackPop(Stack* obj) {
    obj->stkSize--;
}

void stackPush(Stack* obj, int value) {
    obj->stk[obj->stkSize++] = value;
}

typedef struct {//在CQueue中定义两个成员，分别是输出栈和输入栈。
    Stack* inStack;
    Stack* outStack;
} CQueue;

Stack* stackCreate(int capacity)
{
    Stack* ret = malloc(sizeof(Stack));
    ret->stk = malloc(sizeof(int) * capacity);
    ret->stkSize = 0;
    ret->stkCapacity = capacity;
    return ret;
}

CQueue* cQueueCreate() {
    CQueue* ret = malloc(sizeof(CQueue));
    ret->inStack = stackCreate(10000);
    ret->outStack = stackCreate(10000);
    return ret;
}

void cQueueAppendTail(CQueue* obj, int value) {
    obj->inStack->stk[obj->inStack->stkSize++] = value;
}

int cQueueDeleteHead(CQueue* obj) {
    if(obj->outStack->stkSize == 0)
    {
        if(obj->inStack->stkSize == 0)
        {
            return -1;
        }
        while(obj->inStack->stkSize != 0)
        {
            stackPush(obj->outStack,stackTop(obj->inStack));
            stackPop(obj->inStack);
        }
    }
    int x = stackTop(obj->outStack);
    stackPop(obj->outStack);
    return x;
}

void cQueueFree(CQueue* obj) {
    free(obj->inStack);
    free(obj->outStack);
}