算法训练营打卡Day10

最新推荐文章于 2024-09-28 20:31:26 发布

idris的算法日记

最新推荐文章于 2024-09-28 20:31:26 发布

阅读量200

点赞数 10

文章标签：数据结构 c语言 python 算法 leetcode

本文链接：https://blog.csdn.net/Zoe_igxgx/article/details/142406404

版权

今日打卡内容：栈与队列

理论基础

方便读者了解栈和队列，下方是学习的链接

文章讲解：代码随想录

232.用栈实现队列

题目链接：代码随想录、. - 力扣（LeetCode）

栈的基本操作！ | LeetCode：232.用栈实现队列_哔哩哔哩_bilibili

Python

class MyQueue(object):
    def __init__(self):
        self.stack_in = []
        self.stack_out = []
    def push(self, x):
        self.stack_in.append(x)
    def pop(self):
        if self.empty:
            #如果队列中为空，返回None，表示此时队列中没有元素
            return None
        if self.stack_out:
            #如果出栈有元素，执行pop操作
            return stack_out.pop()
        else:
            #如果出栈是空的，但是入栈有元素，就先往出栈push元素，然后再输出
            #相当于没有生活费了，家里打一笔钱然后再消费~~
            for i in range(len(self.stack_in)):
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()
    def peek(self):
        #调用pop()方法，把调用后的返回值存储给res
        res = self.pop()
        #往出栈中塞入res
        self.stack_out.append(res)
        return res
    def empty(self):
        #只要stack_in或者stack_out有元素，说明队列不为空
        return not self.stack_in and not self.stack_out

C

/*
1.两个type为int的数组（栈），大小为100
    第一个栈stackIn用来存放数据，第二个栈stackOut作为辅助用来输出数据
2.两个指针stackInTop和stackOutTop，分别指向栈顶
*/
typedef struct {
    int stackInTop, stackOutTop;
    int stackIn[100], stackOut[100];
} MyQueue;

/*
1.开辟一个队列的大小空间
2.将指针stackInTop和stackOutTop初始化为0
3.返回开辟的队列
*/
MyQueue* myQueueCreate() {
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    queue->stackInTop = 0;
    queue->stackOutTop = 0;
    return queue;
}

/*
将元素存入第一个栈中,存入后栈顶指针+1
*/
void myQueuePush(MyQueue* obj, int x) {
    obj->stackIn[(obj->stackInTop)++] = x;
}

/*
1.若输出栈为空且当第一个栈中有元素（stackInTop>0时），将第一个栈中元素复制到第二个栈中（stackOut[stackTop2++] = stackIn[--stackTop1])
2.将栈顶元素保存
3.当stackTop2>0时，将第二个栈中元素复制到第一个栈中(stackIn[stackTop1++] = stackOut[--stackTop2])
*/
int myQueuePop(MyQueue* obj) {
    //优化：复制栈顶指针，减少对内存的访问次数
    int stackInTop = obj->stackInTop;
    int stackOutTop = obj->stackOutTop;
    //若输出栈为空
    if(stackOutTop == 0) {
        //将第一个栈中元素复制到第二个栈中
        while(stackInTop > 0) {
            obj->stackOut[stackOutTop++] = obj->stackIn[--stackInTop];
        }
    }
    //将第二个栈中栈顶元素（队列的第一个元素）出栈，并保存
    int top = obj->stackOut[--stackOutTop];
    //将输出栈中元素放回输入栈中
    while(stackOutTop > 0) {
        obj->stackIn[stackInTop++] = obj->stackOut[--stackOutTop];
    }
    //更新栈顶指针
    obj->stackInTop = stackInTop;
    obj->stackOutTop = stackOutTop;
    //返回队列中第一个元素
    return top;
}

//返回输入栈中的栈底元素
int myQueuePeek(MyQueue* obj) {
    return obj->stackIn[0];
}

//若栈顶指针均为0，则代表队列为空
bool myQueueEmpty(MyQueue* obj) {
    return obj->stackInTop == 0 && obj->stackOutTop == 0;
}

//将栈顶指针置0
void myQueueFree(MyQueue* obj) {
    obj->stackInTop = 0;
    obj->stackOutTop = 0;
}

225. 用队列实现栈

题目链接：. - 力扣（LeetCode）

C

typedef struct queue {
    int* data;
    int head;
    int rear;
    int size;
} Queue;

typeder struct {
    Queue *queue1, *queue2;
}MyStack;

Queue *initQueue(int k){
    Queue *obj = (Queue *)malloc(sizeof(Queue));
    obj->data = (int *)malloc(k * sizeof(int));
    obj->head = -1;
    obj->rear = -1;
    obj->size = k;
    return obj;
}

int deQueue(Queue *obj){
    int a = obj->data[obj->head];
    if (obj->head == obj->rear){
        obj->rear = -1;
        obj->head = -1;
        return a;
    }
    obj->head = (obj->head + 1) % obj->size;
}
int isEmpty(Queue *obj){
    return obj->head == -1;
}

MyStack* myStackCreate() {
    MyStack *obj = (MyStack *)malloc(sizeof(MyStack));
    obj->queue1 = initQueue(LEN);
    obj->queue2 = initQueue(LEN);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if (isEmpty(obj->queue1)){
        enQueue(obj->queue2,x);
    }
    else{
        enQueue(obj->queue1,x);
    }
}

int myStackPop(MyStack* obj) {
    if (isEmpty(obj->queue1)){
        while (obj->queue2->head != obj->queue2->rear){
            enQueue(obj->queue1,deQueue(obj->queue2));
        }
        return deQueue(obj->queue2);
    }
    while (obj->queue1);
}

int myStackTop(MyStack* obj) {
    if (isEmpty(obj->queue1)){
        return obj->queue2->data[obj->queue2->rear];
    }
    return obj->queue1->data[obj->queue1->rear];
}

bool myStackEmpty(MyStack* obj) {
    if (obj->queue1->head == -1 && obj->queue2->head == -1){
        return true;
    }
    else{
        return false;
    }
}

void myStackFree(MyStack* obj) {
    free(obj->queue1->data);
    obj->queue1->data;
    
    free(obj->queue1);
    obj->queue1 = NULL;

    free(obj->queue2->data);
    obj->queue2->data = NULL；

    free(obj);
    obj = NULL;
}