栈与队列题目

Posted 2022-12-07 ~千里之行，始于足下~

20. 有效的括号
    给定一个只包括 ‘(’，‘)’，‘’，‘’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
    
    链接

class Solution 
public:
    bool isValid(string s) 
        stack<char> stack;
        for (int i = 0; i < s.size(); i++)
        
            if (s[i] == '(')
            
                stack.push(')');
            
            else if (s[i] == '')
            
                stack.push('');
            
            else if (s[i] == '[')
            
                stack.push(']');
            
            else if (stack.empty() || stack.top() != s[i])
                return false;
            else
                stack.pop();
        
        return stack.empty();
    


;

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

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

实现 MyStack 类：

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

链接

class MyStack 
public:
    queue<int> q;
    MyStack() 
    
    
    void push(int x) 
        q.push(x);
    
    
    int pop() 
        queue<int> tmp;
        int size = q.size();
        size--;
        while (size--)
        
            tmp.push(q.front());
            q.pop();
        
        int ans = q.front();
        q.pop();
        q = tmp;
        while (!tmp.empty())
        
            tmp.pop();
        
        return ans;
    
    
    int top() 
        return q.back();
    
    
    bool empty() 
        return q.empty();
    
;

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

实现 MyQueue 类：

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

链接

class MyQueue 
public:
    stack<int>sin;
    stack<int>sout;
    MyQueue() 

    
    
    void push(int x) 
        sin.push(x);
    
    
    int pop() 
        if (sout.empty())
        
            while (!sin.empty())
            
                sout.push(sin.top());
                sin.pop();
            
        
        int ans = sout.top();
        sout.pop();
        return ans;
    
    
    int peek() 
        int tmp = this->pop();
        sout.push(tmp);
        return tmp;
    
    
    bool empty() 
        return sin.empty() && sout.empty();
    
;

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

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

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

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

链接

typedef struct 
    int rear;
    int front;
    int * arr;
    int cnt; //数量(区分满还是空)
    int cap; //容量

 MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
    MyCircularQueue * queue = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (!queue)
    
        return NULL;
    
    queue->arr = (int *)malloc(k*sizeof(int));
    if (!(queue->arr))
    
        free(queue);
        return NULL;
    

    memset(queue->arr, -1, sizeof(int)*k);

    queue->front = queue->rear = 0;
    queue->cnt = 0;
    queue->cap = k;
    return queue;




bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
    return (obj->cnt == 0 && obj->front == obj->rear);


bool myCircularQueueIsFull(MyCircularQueue* obj) 
    return (obj->cnt == obj->cap && obj->rear == obj->front);


bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
    if (myCircularQueueIsFull(obj))
       return false;
    obj->arr[obj->rear] = value;
    obj->rear = (obj->rear+1) % obj->cap;
    obj->cnt++;
    return true;


bool myCircularQueueDeQueue(MyCircularQueue* obj) 
    if (myCircularQueueIsEmpty(obj))
       return false;
    obj->front = (obj->front+1) % obj->cap;
    obj->cnt--;
    return true;


int myCircularQueueFront(MyCircularQueue* obj) 
    if (myCircularQueueIsEmpty(obj))
       return -1;
    return obj->arr[obj->front];


//若此时rear为0
int myCircularQueueRear(MyCircularQueue* obj) 
    if (myCircularQueueIsEmpty(obj))
       return -1;
    return obj->arr[(obj->rear-1+obj->cap)%obj->cap];


void myCircularQueueFree(MyCircularQueue* obj) 
    if (obj)
    
        if (obj->arr)
        
            free(obj->arr);
            obj->arr = NULL;
        
        free(obj);
        obj = NULL;
    

链接

class MaxQueue 
public:
    queue<int> q;
    deque<int> dq;//维护单调递减队列
    MaxQueue() 
    
    
    int max_value() 
        if (dq.empty())
           return -1;
        return dq.front();
    
    
    void push_back(int value) 
        while (!dq.empty() && value > dq.back())//后进的数据,后出,小于它的先出
            dq.pop_back();
        q.push(value);
        dq.push_back(value);
    
    
    int pop_front() 
        if (q.empty())
           return -1;
        int val = q.front();
        if (val == dq.front())
        
            dq.pop_front();
        
        q.pop();
        return val;
    
;

链接

class MinStack 
public:
    /** initialize your data structure here. */
    stack<int> s1;
    stack<int> s2;
    MinStack() 
    
    
    void push(int x) 
        s1.push(x);
        if (s2.empty() || x <= s2.top())
           s2.push(x);
    
    
    void pop() 
        int val = s1.top();
        s1.pop();
        if (val == s2.top())
        
            s2.pop();
        
    
    
    int top() 
        return s1.top();
    
    
    int min() 
        return s2.top();
    
;