栈和队列的应用

最新推荐文章于 2024-08-02 20:41:30 发布

遥遥远方近在咫尺

最新推荐文章于 2024-08-02 20:41:30 发布

阅读量712

点赞数 18

文章标签：栈队列 leetcode

本文链接：https://blog.csdn.net/2402_82658387/article/details/138710971

版权

前言：本文主要讲解一些通过栈和对列的题，这些题都来自leetcode。

OJ题一：

题目：

225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：
输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False
提示：

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

题目中要实现的接口：

typedef struct {
    
} MyStack;


MyStack* myStackCreate() {
    
}

void myStackPush(MyStack* obj, int x) {
    
}

int myStackPop(MyStack* obj) {
    
}

int myStackTop(MyStack* obj) {
    
}

bool myStackEmpty(MyStack* obj) {
    
}

void myStackFree(MyStack* obj) {
    
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

思路：

因为要用到队列，所以，需要有以前写的队列的接口 ，如果没有可以看我写的队列，如果以前写过直接复制粘贴过来就可以了，如果没写过，建议先写完了再来做这一块。

队列与栈的不同：队列的特点就是先进先出，栈的特点就是后进先出（先进后出），

难点：队列出数据是从队头，而栈是在栈顶，两个的出数据的方式不同，如果用队列实现出栈，栈的栈顶相当于队列的队尾，那么就是队列出数据时，出的是队尾的数据。

那么如何解决这个难点呢？

这里实现的思路就是双队列的方式实现栈，这里有队列1和队列2，假设此时队列1为空，队列2中有数据，那么出栈就是，将队列中出队尾的数据，全都pop进队列1，然后再pop队列而中的最后一个数据，这样就用队列实现了出栈。

注意：每次出栈是要将非空队列的size-1个数据QueuePop进另一个空队列中，最后在QueuePop出的数据就是出栈所需的数据。

图示：

答案：

答案部分2（需要实现的接口部分）：

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;



MyStack* myStackCreate() {
    MyStack* my_stack = (MyStack*)malloc(sizeof(MyStack));
    if(my_stack==NULL)
    {
        return NULL;
    }
    QueueInit(&my_stack->q1);
    QueueInit(&my_stack->q2);
    return my_stack;
}

//入栈直接往非空队列如就可以
void myStackPush(MyStack* obj, int x) {
    
    if(!QueueEmpty(&obj->q2))
    {
        QueuePush(&obj->q2,x);
    }
    else
    {
        QueuePush(&obj->q1,x);
    }


}

//难点
int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;//指向空队列
    Queue* nonEmpty = &obj->q2;//指向非空队列
    //假设法
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonEmpty = &obj->q1;
    }
    while(QueueSize(nonEmpty)-1>0)
    {
        int ret = QueueFront(nonEmpty);
        QueuePush(empty,ret);
        QueuePop(nonEmpty);
    }
    int ret = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return ret;
}


int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
        return QueueBack(&obj->q1);
    else
        return QueueBack(&obj->q2);


}


bool myStackEmpty(MyStack* obj) {
    //当两个队列都为空时才为空
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}


void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

答案部分1（这一部分是以前写的队列的代码）：

typedef int QDataType;
typedef struct QNode
{
    struct QNode* next;
    QDataType val;
}QNode;


typedef struct Queue
{
    QNode* phead;
    QNode* ptail;
    int size;//记录队列中的元素个数
}Queue;



// 初始化队列 
void QueueInit(Queue* pq);
// 队尾入队列 
void QueuePush(Queue* pq, QDataType data);
// 队头出队列 
void QueuePop(Queue* pq);
// 获取队列头部元素 
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数 
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq);
// 销毁队列 
void QueueDestroy(Queue* pq);


// 初始化队列 
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->phead = NULL;
    pq->ptail = NULL;
    pq->size = 0;
}
// 队尾入队列 
void QueuePush(Queue* pq, QDataType data)
{
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        return;
    }
    newnode->next = NULL;
    newnode->val = data;
    //队列中没有元素
    if (pq->phead == NULL)
    {
        pq->phead = pq->ptail = newnode;
    }
    else
    {
        pq->ptail->next = newnode;
        pq->ptail = newnode;
    }
    pq->size++;


}
// 队头出队列 
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(pq->phead);
    //只有一个元素
    if (pq->phead->next == NULL)
    {
        free(pq->phead);
        pq->phead = pq->ptail = NULL;
    }
    else
    {
        QNode* del = pq->phead;
        pq->phead = pq->phead->next;
        free(del);
    }
    pq->size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->phead);
    return pq->phead->val;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->ptail);
    return pq->ptail->val;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
    assert(pq);
    return pq->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->size == 0;
}
// 销毁队列 
void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->phead;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    pq->phead = NULL;
    pq->ptail = NULL;
    pq->size = 0;
}

OJ题二：

题目：

232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：
输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。




typedef struct {
    
} MyQueue;


MyQueue* myQueueCreate() {
    
}

void myQueuePush(MyQueue* obj, int x) {
    
}

int myQueuePop(MyQueue* obj) {
    
}

int myQueuePeek(MyQueue* obj) {
    
}

bool myQueueEmpty(MyQueue* obj) {
    
}

void myQueueFree(MyQueue* obj) {
    
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

思路：

难点：还是像第一题一样，如何通过栈实现队列的出队？

解决：

采用双栈的形式，假设栈1为空，栈2 有数据，

1，现将栈1的size-1个数据，StackPop进栈2，

2，然后第Size个数据被StackPop后就相当于QueuePop，

3，将栈2的数据再全部StackPop回栈1

图示：

答案：

//栈的实现
typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;
    int top;        // 栈顶
    int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* pst);
// 入栈 
void StackPush(Stack* pst, STDataType data);
// 出栈 
void StackPop(Stack* pst);
// 获取栈顶元素 
STDataType StackTop(Stack* pst);
// 获取栈中有效元素个数 
int StackSize(Stack* pst);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* pst);
// 销毁栈 
void StackDestroy(Stack* pst);



void StackInit(Stack* pst)
{
    assert(pst);
    pst->arr = NULL;
    pst->top = 0;
    pst->capacity = 0;
}
// 入栈 
void StackPush(Stack* pst, STDataType data)
{
    //扩容
    if (pst->top == pst->capacity)
    {
        int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
        STDataType* tmp = (STDataType*)realloc(pst->arr, newcapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        pst->capacity = newcapacity;
        pst->arr = tmp;
    }
    pst->arr[pst->top++] = data;
}
// 出栈 
void StackPop(Stack* pst)
{
    assert(pst);
    assert(pst->top > 0);
    pst->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* pst)
{
    assert(pst);
    return pst->arr[pst->top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* pst)
{
    assert(pst);
    return pst->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* pst)
{
    return pst->top == 0;
}
// 销毁栈 
void StackDestroy(Stack* pst)
{
    free(pst->arr);
    pst->arr = NULL;
    pst->top = 0;
    pst->capacity = 0;
}
//栈的实现end



typedef struct {
    Stack st1;//空栈
    Stack st2;//非空
} MyQueue;



MyQueue* myQueueCreate() {
    MyQueue* my_queue = (MyQueue*)malloc(sizeof(MyQueue));


    StackInit(&my_queue->st1);


    StackInit(&my_queue->st2);
    return my_queue;
}


void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->st2, x);
}


int myQueuePop(MyQueue* obj) {


    while (StackSize(&obj->st2) - 1 > 0)
    {
        int tmp = StackTop(&obj->st2);
        StackPop(&obj->st2);
        StackPush(&obj->st1, tmp);
    }
    int ret = StackTop(&obj->st2);
    StackPop(&obj->st2);
    while (StackSize(&obj->st1) > 0)
    {
        int tmp = StackTop(&obj->st1);
        StackPop(&obj->st1);
        StackPush(&obj->st2, tmp);
    }
    return ret;
}

//注意这里只是获得栈顶元素，所以第一次挪完数据后不能Pop
int myQueuePeek(MyQueue* obj) {
    while (StackSize(&obj->st2) - 1 > 0)
    {
        int tmp = StackTop(&obj->st2);
        StackPop(&obj->st2);
        StackPush(&obj->st1, tmp);
    }
    int ret = StackTop(&obj->st2);
    while (StackSize(&obj->st1) > 0)
    {
        int tmp = StackTop(&obj->st1);
        StackPop(&obj->st1);
        StackPush(&obj->st2, tmp);   
    }
    return ret;
}


bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->st2);
}


void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->st1);
    StackDestroy(&obj->st2);
    free(obj);
}

OJ题三：

题目：

622. 设计循环队列

设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

示例：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4
提示：

所有的值都在 0 至 1000 的范围内；
操作数将在 1 至 1000 的范围内；
请不要使用内置的队列库。




typedef struct {
    
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    
}

int myCircularQueueFront(MyCircularQueue* obj) {
    
}

int myCircularQueueRear(MyCircularQueue* obj) {
    
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    
}

void myCircularQueueFree(MyCircularQueue* obj) {
    
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

思路：

这里使用数组来实现队列，

难点：这里需要判断队列是否满，有两种方法：

1，在定义队列结构体变量是，在里面加入一个size变量记录队列中元素的个数。

2，就是在开辟数组是开辟k+1个元素的大小的空间

这里采用的是第二种方案。

为什么是开辟k+1个元素的大小的空间？

如果开辟的是k个元素的空间大小时，循环队列为空或循环全部被插入数据时，head和tail都指向同一个位置，判断不了此时循环队列是空还是满。

如果多开辟一个空间，当循环链表满是tail和head也不指向一个位置，那么就可以区别开，满和空队列了

还有要注意一下：需要使下标实现循环

当插入数据时，tail会指向数组下标为k+1的地方，因为是循环链表所以此时tail不应该指向k+1，而应该指向0。这种情况下标实现循环的方法tail =（tail+1）%（k+1）

如果tail指向0时，此时pop数据后tail也不应该指向-下标为-1的位置，而应该指向下标为k的位置。

这种情况下标实现循环的方法tail =（tail-1+k+1）%（k+1）

答案：

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;



MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (pq == NULL)
        return NULL;
    pq->a = (int*)malloc(sizeof(int)*(k+1));
    pq->head = 0;
    pq->tail = 0;
    pq->k = k;
    return pq;
}


bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    int k = obj->k;
    if ((obj->tail + 1) % (k + 1) == obj->head)//一下类似的表达式都是使下标实现循环的意思
        return false;
    obj->a[obj->tail++] = value;
    obj->tail = obj->tail % (k + 1);
    return true;
}

//注意删数据删的是队头的数据，第一次写的时候删的是队尾的调试了老长时间才发现
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    int k = obj->k;
    if (obj->head == obj->tail)
        return false;
    obj->head = (obj->head + 1 ) % (k + 1);
    return true;
}


int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->head == obj->tail)
        return -1;
    return obj->a[obj->head];
}


int myCircularQueueRear(MyCircularQueue* obj) {
    int k = obj->k;
    if (obj->head == obj->tail)
        return -1;
    return obj->a[(obj->tail-1+k+1)%(k+1)];
}


bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if (obj->head == obj->tail)
        return true;
    return false;
}


bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int k = obj->k;
    if ((obj->tail + 1) % (k + 1) == obj->head)
        return true;
    return false;
}


void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

结语：希望这篇文章能够让你有所收获。