面试题·栈和队列的相互实现·详解

最新推荐文章于 2024-06-14 00:06:25 发布
最新推荐文章于 2024-06-14 00:06:25 发布
阅读量914 收藏 31
点赞数 24
文章标签： 数据结构 c语言 c++ 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80357424/article/details/139218906
版权

A. 用队列实现栈

用队列实现栈
实现代码如下
看着是队列，其实实际实现更接近数组模拟

typedef struct {
    int* queue1;    // 第一个队列
    int* queue2;    // 第二个队列
    int size;       // 栈的大小
    int front1, rear1, front2, rear2;  // 两个队列的首尾指针
} MyStack;

//初始化栈
MyStack* myStackCreate() {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    stack->queue1 = (int*)malloc(sizeof(int) * 100);
    stack->queue2 = (int*)malloc(sizeof(int) * 100);
    stack->size = 0;
    stack->front1 = stack->rear1 = 0;
    stack->front2 = stack->rear2 = 0;
    return stack;
}

//将元素 x 压入栈顶 
void myStackPush(MyStack* obj, int x) {
    obj->queue1[obj->rear1++] = x;  // 将元素加入 queue1 的尾部
    obj->size++;
}

//移除并返回栈顶元素 
int myStackPop(MyStack* obj) {
    int i;
    // 将 queue1 中的元素(除了最后一个)转移到 queue2 中
    for (i = 0; i < obj->size - 1; i++) {
        obj->queue2[obj->rear2++] = obj->queue1[obj->front1++];
    }
    int top = obj->queue1[obj->front1++];  // 获取栈顶元素
    obj->size--;
    
    // 交换 queue1 和 queue2,为下次操作做准备
    int* temp = obj->queue1;
    obj->queue1 = obj->queue2;
    obj->queue2 = temp;
    obj->front1 = 0;
    obj->rear1 = obj->size;
    obj->front2 = 0;
    obj->rear2 = 0;
    
    return top;
}

//返回栈顶元素 
int myStackTop(MyStack* obj) {
    int i;
    // 将 queue1 中的元素转移到 queue2 中
    for (i = 0; i < obj->size; i++) {
        obj->queue2[obj->rear2++] = obj->queue1[obj->front1++];
    }
    int top = obj->queue2[obj->rear2 - 1];  // 获取栈顶元素
    
    // 交换 queue1 和 queue2,为下次操作做准备
    int* temp = obj->queue1;
    obj->queue1 = obj->queue2;
    obj->queue2 = temp;
    obj->front1 = 0;
    obj->rear1 = obj->size;
    obj->front2 = 0;
    obj->rear2 = 0;
    
    return top;
}

//如果栈是空的,返回 true;否则,返回 false 
bool myStackEmpty(MyStack* obj) {
    return obj->size == 0;
}

void myStackFree(MyStack* obj) {
    free(obj->queue1);
    free(obj->queue2);
    free(obj);
}

虽然注释已经够详细了，但是我们还是来逐步分析一下
代码实际上并没有使用链式队列，而是使用了两个固定大小的数组来模拟栈的行为。

首先，我们定义了一个结构体MyStack，它包含两个整数数组queue1和queue2（其实在这里，它们更像栈，因为数组是按照后进先出的顺序使用的），以及它们的前后端指针和栈的大小。

myStackCreate

这个函数用于初始化栈。它分配了MyStack结构体的内存，并为两个数组分配了内存。然后，它初始化了所有的指针和大小为0。

myStackPush
这个函数用于将元素压入栈顶。它简单地将元素添加到queue1的尾部，并更新rear1指针和栈的大小。

myStackPop
这个函数用于移除并返回栈顶元素。但是，这里有一个问题：它实际上将整个queue1（除了最后一个元素）转移到了queue2，然后返回了queue1的最后一个元素。之后，它交换了两个数组，并重置了所有的指针。这样做在每次pop操作时都非常低效，因为它涉及到大量元素的移动。

一个更高效的方法是，每次pop时，只需要记录queue1的最后一个元素（即栈顶元素），然后将其余元素（如果有的话）从queue1转移到queue2，并交换两个队列的引用。但是，在交换后，不需要重置所有的指针，因为queue2的front2和rear2已经指向了正确的位置。

myStackTop
这个函数与myStackPop非常相似，但是它返回栈顶元素而不移除它。然而，与myStackPop一样，它也涉及到了不必要的元素移动和数组交换。

myStackEmpty
这个函数检查栈是否为空，通过检查栈的大小是否为0来实现。

myStackFree
这个函数释放了栈所使用的所有内存。

改进建议

  1. 避免不必要的元素移动：在pop和top操作中，只需要移动除了栈顶元素之外的其他元素。
  2. 减少指针重置：在交换数组后，不需要总是重置所有的前端和后端指针。
  3. 考虑使用真正的链式队列：如果你想要一个链式栈，你应该使用链式队列（通过节点连接）而不是数组。链式实现会更灵活，并且在处理大量数据时可能更高效。
  4. 错误处理：在分配内存时，应该检查malloc是否成功，并在失败时返回错误或进行其他处理。
  5. 边界检查：在pop和top操作中，应该检查栈是否为空，以避免访问空指针或未定义的内存。
  6. 优化内存使用：如果你知道栈的大小上限，可以使用固定大小的数组。但是，如果你想要一个可以动态增长的栈，那么链式实现可能更合适。

下面是优化后的代码

在这个版本中，我们使用了一个指针queue和两个布尔值（但实际上我们只需要一个，因为!isQueue1就等同于isQueue2）来追踪当前正在使用的队列。当栈满时，我们尝试扩容，并将元素从queue2（如果它包含元素）复制到queue1。我们还添加了一个检查，以便在queue1使用了超过一半的空间时，将元素从queue1复制到queue2，并切换队列，以保持两个队列之间的负载均衡。

我们还在myStackFree函数中释放了内存，并处理了malloc和realloc可能返回NULL的情况。

#include <stdlib.h>  
#include <stdbool.h>  
  
#define INITIAL_CAPACITY 100  
  
typedef struct {  
    int* queue;  
    int capacity;  
    int top;  
    bool isQueue1; // 表示当前正在使用queue1还是queue2  
} MyStack;  
  
MyStack* myStackCreate() {  
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));  
    if (!obj) return NULL;  
  
    obj->queue = (int*)malloc(INITIAL_CAPACITY * sizeof(int));  
    if (!obj->queue) {  
        free(obj);  
        return NULL;  
    }  
  
    obj->capacity = INITIAL_CAPACITY;  
    obj->top = -1; // 栈顶指针初始化为-1，表示空栈  
    obj->isQueue1 = true; // 初始时使用queue1  
  
    return obj;  
}  
  
void myStackPush(MyStack* obj, int x) {  
    if (obj->top == obj->capacity - 1) { // 栈满，扩容  
        int newCapacity = obj->capacity * 2;  
        int* newQueue = (int*)realloc(obj->isQueue1 ? obj->queue : (obj->queue - INITIAL_CAPACITY), newCapacity * sizeof(int));  
        if (!newQueue) return; // 扩容失败  
  
        obj->queue = newQueue + (obj->isQueue1 ? 0 : INITIAL_CAPACITY); // 调整指针，确保obj->queue始终指向当前使用的队列  
        obj->capacity = newCapacity;  
  
        // 如果之前使用queue2，现在切换回queue1，则需要复制数据  
        if (!obj->isQueue1) {  
            for (int i = 0; i <= obj->top; i++) {  
                obj->queue[i] = obj->queue[i + INITIAL_CAPACITY];  
            }  
            obj->isQueue1 = true; // 切换回queue1  
        }  
    }  
  
    obj->queue[++obj->top] = x; // 压栈  
}  
  
int myStackPop(MyStack* obj) {  
    if (obj->top == -1) return -1; // 栈空  
  
    int x = obj->queue[obj->top--]; // 弹出栈顶元素  
  
    // 如果queue1已经使用了超过一半的空间，且queue2是空的，则考虑将queue1的元素移到queue2，并切换队列  
    if (obj->isQueue1 && obj->top > obj->capacity / 4) {  
        for (int i = 0; i <= obj->top; i++) {  
            obj->queue[i + INITIAL_CAPACITY] = obj->queue[i];  
        }  
        obj->isQueue1 = false; // 切换到queue2  
        obj->top += INITIAL_CAPACITY; // 更新top指针  
    }  
  
    return x;  
}  
  
int myStackTop(MyStack* obj) {  
    if (obj->top == -1) return -1; // 栈空  
    return obj->queue[obj->top]; // 返回栈顶元素  
}  
  
bool myStackEmpty(MyStack* obj) {  
    return obj->top == -1; // 检查栈是否为空  
}  
  
void myStackFree(MyStack* obj) {  
    if (obj) {  
        free(obj->queue - (obj->isQueue1 ? 0 : INITIAL_CAPACITY)); // 释放队列内存  
        free(obj);  
    }  
}

B. 用栈实现队列

用栈实现队列

那用链栈来实现一下看看

// 链表节点定义  
typedef struct Node {  
    int data;  
    struct Node* next;  
} Node;  
  
// 栈结构定义
typedef struct Stack {  
    Node* top;  
    int size;  
} Stack;  
  
// MyQueue结构体定义，包含两个栈  
typedef struct MyQueue {  
    Stack* stack1;  
    Stack* stack2;  
} MyQueue;  
// 创建新的节点  
Node* createNode(int data) {  
    Node* newNode = (Node*)malloc(sizeof(Node));  
    if (!newNode) {  
        perror("Memory allocation failed");  
        exit(EXIT_FAILURE);  
    }  
    newNode->data = data;  
    newNode->next = NULL;  
    return newNode;  
}  
  
// 初始化栈  
Stack* createStack() {  
    Stack* stack = (Stack*)malloc(sizeof(Stack));  
    if (!stack) {  
        perror("Memory allocation failed");  
        exit(EXIT_FAILURE);  
    }  
    stack->top = NULL;  
    stack->size = 0;  
    return stack;  
}  
  
// 压栈操作  
void push(Stack* stack, int data) {  
    Node* newNode = createNode(data);  
    newNode->next = stack->top;  
    stack->top = newNode;  
    stack->size++;  
}  
  
// 出栈操作  
int pop(Stack* stack) {  
    if (stack->size == 0) {  
        printf("Stack is empty.\n");  
        exit(EXIT_FAILURE);  
    }  
    Node* temp = stack->top;  
    int data = temp->data;  
    stack->top = temp->next;  
    free(temp);  
    stack->size--;  
    return data;  
}  
  
// 查看栈顶元素  
int peek(Stack* stack) {  
    if (stack->size == 0) {  
        printf("Stack is empty.\n");  
        exit(EXIT_FAILURE);  
    }  
    return stack->top->data;  
}  
  
// 判断栈是否为空  
int isEmpty(Stack* stack) {  
    return stack->size == 0;  
}  
  
// 释放栈内存  
void freeStack(Stack* stack) {  
    Node* current = stack->top;  
    Node* temp;  
    while (current != NULL) {  
        temp = current;  
        current = current->next;  
        free(temp);  
    }  
    free(stack);  
}

MyQueue* myQueueCreate() {  
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));  
    if (!queue) {  
        perror("Memory allocation failed for MyQueue");  
        exit(EXIT_FAILURE);  
    }  
    queue->stack1 = createStack();  
    queue->stack2 = createStack();  
    return queue;  
}  
  
void myQueuePush(MyQueue* queue, int data) {  
    push(queue->stack1, data);  
}  
  
int myQueuePop(MyQueue* queue) {  
    if (isEmpty(queue->stack2)) {  
        while (!isEmpty(queue->stack1)) {  
            push(queue->stack2, pop(queue->stack1));  
        }  
    }  
    if (isEmpty(queue->stack2)) {  
        return -1; // 队列为空，无法弹出元素  
    }  
    return pop(queue->stack2);  
}  
  
int myQueuePeek(MyQueue* queue) {  
    if (isEmpty(queue->stack2)) {  
        while (!isEmpty(queue->stack1)) {  
            push(queue->stack2, pop(queue->stack1));  
        }  
    }  
    if (isEmpty(queue->stack2)) {  
        return -1; // 队列为空，无法查看队首元素  
    }  
    return peek(queue->stack2);  
}  
  
bool myQueueEmpty(MyQueue* queue) {  
    return isEmpty(queue->stack1) && isEmpty(queue->stack2);  
}  
  
void myQueueFree(MyQueue* queue) {  
    freeStack(queue->stack1);  
    freeStack(queue->stack2);  
    free(queue);  
}

这段代码实现了一个基于两个栈的队列结构 MyQueue。下面我们来逐步解释这段代码:

  1. 链表节点定义：

    • Node 结构体定义了链表节点, 包含一个整数值 data 和指向下一个节点的指针 next。

  2. 栈结构定义：

    • Stack 结构体定义了一个栈, 包含指向栈顶元素的指针 top 和栈的大小 size。

  3. MyQueue 结构体定义：

    • MyQueue 结构体包含两个 Stack 指针, stack1 和 stack2, 用于实现队列的功能。

  4. 创建新的节点:

    • createNode 函数用于创建一个新的链表节点, 并分配内存。如果内存分配失败, 则输出错误信息并退出程序。

  5. 初始化栈:

    • createStack 函数用于创建一个新的栈, 将栈顶指针设为 NULL, 并将栈的大小设为 0。如果内存分配失败, 则输出错误信息并退出程序。

  6. 压栈操作:

    • push 函数用于将一个元素压入栈, 首先创建一个新节点, 然后将新节点的 next 指针指向当前栈顶元素, 最后更新栈顶指针和栈的大小。

  7. 出栈操作:

    • pop 函数用于从栈中弹出一个元素, 首先检查栈是否为空, 如果为空则输出错误信息并退出程序。然后获取栈顶元素的数据, 更新栈顶指针, 释放栈顶元素的内存, 并更新栈的大小。

  8. 查看栈顶元素:

    • peek 函数用于查看栈顶元素, 首先检查栈是否为空, 如果为空则输出错误信息并退出程序。然后返回栈顶元素的数据。

  9. 判断栈是否为空:

    • isEmpty 函数用于判断栈是否为空, 返回栈的大小是否为 0。

  10. 释放栈内存:

    • freeStack 函数用于释放栈占用的内存, 遍历链表并逐个释放每个节点的内存, 最后释放栈本身的内存。

  11. 创建 MyQueue:

    • myQueueCreate 函数用于创建一个新的 MyQueue 对象, 分配内存并初始化两个 Stack 对象。如果内存分配失败, 则输出错误信息并退出程序。

  12. 入队操作:

    • myQueuePush 函数用于将一个元素入队, 直接将元素压入 stack1 即可。

  13. 出队操作:

    • myQueuePop 函数用于从队列中出队一个元素。首先检查 stack2 是否为空, 如果为空则将 stack1 中的元素全部弹出并压入 stack2。然后从 stack2 中弹出并返回队首元素。如果两个栈都为空, 则返回 -1 表示队列为空。

  14. 查看队首元素:

    • myQueuePeek 函数用于查看队首元素。与出队操作类似, 首先检查 stack2 是否为空, 如果为空则将 stack1 中的元素全部弹出并压入 stack2。然后返回 stack2 的栈顶元素。如果两个栈都为空, 则返回 -1 表示队列为空。

  15. 判断队列是否为空:

    • myQueueEmpty 函数用于判断队列是否为空, 返回 stack1 和 stack2 是否同时为空。

  16. 释放 MyQueue 内存:

    • myQueueFree 函数用于释放 MyQueue 对象占用的内存, 首先释放 stack1 和 stack2 的内存, 然后释放 MyQueue 对象本身的内存。

那么到这里，本篇文章就结束了，这两题虽然没有实用的意义，但是用来理解栈和队列还是非常不错的

期待与你的下次相见！！！
下期预告~二叉树(上)-堆

Sheep Shaun
关注
  • 24
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
ActiveMq工作无忧面试题详解
06-13
介绍：本课程共6节内容，是从“精讲”课程中抽取出来的面试题详解，内容包括基础、主从架构的搭建和访问、分布式集群搭建和访问等。如果您对整个课程感兴趣可以直接在本网站搜索“张立坤”讲师即可查看我的所有课程...
Java中消息队列任务的平滑关闭详解
08-28
对于消息队列的监听，我们一般使用Java写一个独立的程序，在Linux服务器上运行。程序启动后，通过消息队列客户端接收消息，放入一个线程池进行异步处理，并发的快速处理。这篇文章主要给大家介绍了关于Java中消息...
栈和队列经典面试题详解
A13569039691的博客
05-15 1155
栈和队列经典面试题详解
栈和队列详解（附相关面试题）
wjmhlh的博客
08-07 295
栈和队列的详解以及代码实现，相关面试题的解析！
Java之栈和队列详解
qq_73471456的博客
01-23 1331
Java知识来实现数据结构之栈和队列，带你深入了解栈和队列的原理实现
详解栈和队列面试题(C语言版)，含动图和思路分析
iwkxi的博客
03-27 2723
文章目录1.栈和队列面试题1.1[括号匹配问题](https://leetcode-cn.com/problems/valid-parentheses/)1.2. [用队列实现栈](https://leetcode-cn.com/problems/implement-stack-using-queues/) 1.栈和队列面试题 1.1括号匹配问题 //C语言实现栈 typedef char STDataType; typedef struct Stack { STDataType* a; int t
Java后端真实面试题大全(有详细答案)--高频/真题
IT利刃出鞘的博客
11-24 12万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
详解两个栈实现一个队列（python实现——经典面试题）
su_bao的博客
09-03 2069
1、题目说明       使用两个栈结构，实现一个队列功能，实现队列的添加元素和弹出元素。       注意：       队列特点是只能在队列尾部添加元素，在队列头部删除元素，先进先出（FIFO/LILO） 2、结题思路        两个栈可以巧妙的结合，第一个栈用来添加元素，而在第二个栈中弹出元素。        我们把所有添加元素的操作放在第一个栈中实现，当需要弹出元素时全部放...
面试题4---用两个栈实现队列详解
松落
04-10 856
1.题目 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deleteHead,分别完成在队列尾部插入结点和在队列头部删除结点的功能。 2.笔者解答 3.涉及知识点 （一）泛型 重载帮助我们实现了同一函数可以实现不同的功能，也可以接收不同类型的参数。比如当我们想写一个swap（）交换函数时，通常这样写： void swap(int& a,int&b) ...
高频面试题基本总结回顾（含笔试高频算法整理）
热门推荐
张彦峰的博客
04-03 172万+
1.自我介绍+项目介绍+项目细节/难点提问-------这个主要看个人的经历了，每个人都不一样 2.基础知识点考核---------还是可以去增强自己的，也是这次的主要的一些总结思路 3.算法题-----------一般都是LeetCode高频题，这个得在找工作之前的好好的练习(d对常见的高频题进行总结分析，见对应的链接提示)
【数据结构 Java 版】详解栈和队列的实现，如何搞定面试
2401_84438292的博客
04-21 763
现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
509 道 Java 面试题汇总与解析 免费开源！！
10-31
详解 500 多道实用、权威、高频 Java 面试题 这 500 多道面试题，都是目前主流企业使用最高频的面试题库，也都是 Java 版本升级之后，重新整理归纳的最新答案，会让面试者少走很多不必要的弯路。同时每道题都做到了...
京东面试过程总结，面试详解
04-14
10. 算法问题：算法问题包括编程珠玑的一道题、List求和问题等，面试官可能会问到这些问题的解决方案和优化方法。 11. MySQL索引优化：MySQL索引优化问题包括索引创建、区分度、选择性、列基数等，面试官可能会问到...
数据结构：插入排序和希尔排序
Another_Shi的博客
06-10 367
比较，比它小就插入，比它大就放到它的后面。但不是直接的插入，因为我们还不确定更前面有没有比tmp小的数据，所以若遇到比tmp要大的数就直接后移，直到遇到比tmp小的数，就把tmp赋值到end+1的位置。插入排序在我们生活中最常见的例子就是打牌时候的理牌的过程，可以看作为插入排序。我们拿一个数，先和数组的第一个数比较，比它小就插入，比它大就放到它的后面。希尔排序的思想与插入排序很像，不过希尔排序将数组分为了很多小组进行插入排序，然后缩小组的大小直至1，那就跟插入排序一样了。，使其可以多次的单趟排序直至排好。
【数据结构】AVL树（平衡二叉树）
liuty0125的博客
06-10 970
AVL树是一个平衡的二叉搜索树，它的每个节点的左右子树高度差的绝对值不超过1，因此，哪怕最坏也只是查找高度次，保证了查询时高效的时间复杂度O(log_n)。 但是它的缺陷也很明显：如果我们要对AVL树做一些修改方面的操作时，它的性能就十分低了，因为在修改时我们还要维护它的绝对平衡，旋转的次数比较多，而且在删除时，最坏情况可能会更新到根节点。 所以，如果只是需要一种查询高效且有序的数据结构，且数据个数为静态（不改变），比较适合AVL树，但如果你需要经常修改的话，AVL树可能就不太适合了
从零开始学数据结构系列之第三章《中序线索二叉树理论部分》
最新发布
铁匠匠匠的博客
06-14 591
那么，**可不可以在建立二叉树的同时记录下前驱后继的关系，**这样我们在寻找前驱后继结点时的效率将会大大提升！​     所以我们空闲的节点数是 2n - (n-1) = n+1个节点。为了解决这个问题，我们需要添加标志位ltag和rtag,并定义以下规则。那我们能不能利用原本浪费掉的空间，来解决第二个问题呢？​     我们每个节点有2n个指针（左右子树）​     我们有 n - 1 个节点。​   怎么得出n+1个节点的呢？，可以得到1、3、6、8、10，​   倘若对下图二叉树进行。
【数据结构】详解堆排序当中的topk问题（leetcode例题）
ylfxw的博客
06-10 1226
215. 数组中的第K个最大元素。Top K 问题是一个经典的问题，在计算机科学中，它的目标是在一组数据中找到前 K 个最大或最小的元素。这个问题在许多场景下都很重要，比如搜索引擎的搜索结果排名、数据分析中的热门元素筛选等。
rabbitmq面试题消息队列
08-09
此外，RabbitMQ还提供了去重的机制，通过生成inner-msg-id和bizId来避免重复的消息进入队列和重复消费。综上所述，使用RabbitMQ能够提供可靠的消息传输和保证消息的一致性，从而帮助开发者构建可靠的分布式系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值