LeetCode刷题——剑指offer栈和队列题目汇总

剑指 Offer 09. 用两个栈实现队列

题目
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
[“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
[“CQueue”,“deleteHead”,“appendTail”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：

1 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof
分析
我们先将栈底和队首对应，栈顶和队尾对应来分析一下队列和栈操作，在这种情况下入队可以看作入栈，难点在于出队。

出队操作的结果是取出队首第一个元素，对应的是取出栈底元素。要取出栈底元素首先要把其他元素出栈，出栈后的元素压入到另一个栈中，取出栈底元素后再把这些元素放回来。
代码

typedef struct {
    int *values;
    int top;
    int maxlength;
} CQueue;

int step = 10;

CQueue* cQueueCreate() {
    CQueue* obj;
    obj = (CQueue *)malloc(sizeof(CQueue));
    obj->values=(int *)malloc(step * sizeof(int));
    obj->top=-1;
    obj->maxlength=0;
    return obj;
}

int pop(CQueue* obj){
    int values = obj->values[obj->top--];
    return values;
}

void push(CQueue* obj, int value){
    if(obj->top+2 > obj->maxlength){
        obj->maxlength+=step;
        obj->values = (int *)realloc(obj->values, obj->maxlength * sizeof(int));
    }
    obj->values[++obj->top]=value;
}

int getlength(CQueue* obj){
    return obj->top+1;
}

void cQueueAppendTail(CQueue* obj, int value) {
    push(obj, value);
}

int cQueueDeleteHead(CQueue* obj) {
    if(getlength(obj)==0){
        return -1;
    }
    CQueue* tmp = cQueueCreate();
    while(getlength(obj)>1){
        int v = pop(obj);
        push(tmp, v);
    }
    int headvalue = pop(obj);
    while(getlength(tmp)){
        int v = pop(tmp);
        push(obj, v);
    }
    free(tmp->values);
    free(tmp);
    return headvalue;
}

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

/**
 * Your CQueue struct will be instantiated and called as such:
 * CQueue* obj = cQueueCreate();
 * cQueueAppendTail(obj, value);
 
 * int param_2 = cQueueDeleteHead(obj);
 
 * cQueueFree(obj);
*/

剑指 Offer 30. 包含min函数的栈

题目
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof
分析
要求时间复杂度为O(1)，而栈的操作入栈和出栈时间也是O(1)，也就是说要在数据入栈的时候同步存好最大值和最小值就要侧重入栈和出栈。在这里我们定义了一个新的minvalues数组作为最小栈。当一个元素入栈时，如果之前的栈为空很明显这个元素就是最小值。当栈不为空时如果当前元素小于最小栈的值则将这个元素的值同步压到最小栈中，否则将最小栈的最小栈（栈顶元素）压到最小栈的栈顶。栈和最小栈同步入栈和出栈即可保证最小栈的栈顶元素是最小值
代码

typedef struct {
    int* values;
    int* minvalues;
    int top;
    int maxlength;
} MinStack;

/** initialize your data structure here. */
int step=100;

MinStack* minStackCreate() {
    MinStack* obj;
    obj = (MinStack *)malloc(sizeof(MinStack));
    obj->values = (int *)malloc(10000 * sizeof(int));
    obj->minvalues = (int *)malloc(10000 * sizeof(int));
    obj->top = -1;
    obj->maxlength = 10000;
    return obj;
}

void minStackPush(MinStack* obj, int x) {
    if(obj->top+2 > obj->maxlength){
        obj->maxlength += step;
        obj->values = (int *)realloc(obj->values, obj->maxlength*sizeof(int));
        obj->minvalues = (int *)realloc(obj->minvalues, obj->maxlength*sizeof(int));
    }
    if((obj->top == -1) || (x < minStackMin(obj))){
        obj->minvalues[obj->top+1] = x;
    }else{
        obj->minvalues[obj->top+1] = minStackMin(obj);
    }
    obj->values[++obj->top]=x;
}

void minStackPop(MinStack* obj) {
    obj->top--;
}

int minStackTop(MinStack* obj) {
    return obj->values[obj->top];
}

int minStackMin(MinStack* obj) {
    return obj->minvalues[obj->top];
}

void minStackFree(MinStack* obj) {
    free(obj->values);
    free(obj->minvalues);
    free(obj);
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, x);
 
 * minStackPop(obj);
 
 * int param_3 = minStackTop(obj);
 
 * int param_4 = minStackMin(obj);
 
 * minStackFree(obj);
*/

剑指 Offer 59 - I. 滑动窗口的最大值

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]

解释:

滑动窗口的位置	最大值
[1 3 -1] -3 5 3 6 7	3
1 [3 -1 -3] 5 3 6 7	3
1 3 [-1 -3 5] 3 6 7	5
1 3 -1 [-3 5 3] 6 7	5
1 3 -1 -3 [5 3 6] 7	6
1 3 -1 -3 5 [3 6 7]	7

提示：

• 你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

分析
我们可以利用双端队列来维护一个单调非递减的队列来表示当前的最大值，由于队列单调非减，队首的元素即为最小元素。详细分析请参照下一题
代码

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        deque<int> dq; 
        if(nums.size()==0||k==0){
            return ans;
        }
        for(int i=0; i < k; i++){
            while(!dq.empty() && nums[dq.back()] <= nums[i]){
                dq.pop_back();
            }
            dq.push_back(i);
        }
        ans.push_back(nums[dq.front()]);
        for(int i=k; i < nums.size(); i++){
            while(!dq.empty() && nums[dq.back()] <= nums[i]){
                dq.pop_back();
            }
            dq.push_back(i);
            while(dq.front() <= i - k){
                dq.pop_front();
            }
            ans.push_back(nums[dq.front()]);
        }
        return ans;
    }
};

剑指 Offer 59 - II. 队列的最大值

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入:
[“MaxQueue”,“push_back”,“push_back”,“max_value”,“pop_front”,“max_value”]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

示例 2：

输入:

[“MaxQueue”,“pop_front”,“max_value”]
[[],[],[]]
输出: [null,-1,-1]

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

分析
在队列入队的过程中，双向队列应该从后边入队，这时前边如果有比当前元素小的元素，不对队列的最大值产生影响，所以可以直接出队。当队列出队时如果出队元素正好是双向队列中首部的元素，说明当前的最大元素已经出队列了，这时应该将双向队列的首部元素出队
代码

class MaxQueue {
public:
    MaxQueue() {

    }
    queue<int> q;
    deque<int> dq;
    int max_value() {
        if(dq.empty()){
            return -1;
        }
        return dq.front();
    }
    
    void push_back(int value) {
        q.push(value);
        while(!dq.empty() && dq.back() < value){
            dq.pop_back();
        }
        dq.push_back(value);
    }
    
    int pop_front() {
        if(q.empty()){
            return -1;
        }
        int value = q.front();
        if(dq.front() == value){
            dq.pop_front();
        }
        q.pop();
        return value;
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */