6、栈与队列相关

上一节：5、双指针相关

下一节：7、二叉树相关

栈与队列

1、定义

参考 此篇博客的介绍

栈的定义

栈是限定仅在表的一端进行插入和删除操作的线性表；
将允许插入删除的一段称为栈顶(top)，另一端称为栈底(buttom)，不含任何元素的栈称为空栈。
栈又称为后进先出的线性表，简称LIFO结构。

栈的插入操作，叫作进栈。
删除操作，叫作出栈。
如图，分别表示进栈与入栈操作。

队列的定义

队列是只允许在表的一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出的线性表，简称FIFO。
允许插入的一端是队尾，允许删除的一端是队头。
假设队列是q=(a1,a2,…,an)，那么a1是队头，an是队尾。如图所示：

2、栈实现队列

leetcode 232. 用栈实现队列

232. 用栈实现队列
使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。
示例:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

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

使用两个队列模拟栈的操作，
C语言代码如下：

/* 构造一个栈：
 * 栈指针、栈的大小、栈的最大容量
 */
typedef struct Stack {
    int* stk;
    int stkSize;
    int stkCapcaity;
}T_Stack, *PT_Stack;

/* 栈的初始化 */
PT_Stack stackCreate(int capacity) {
    PT_Stack ret = (PT_Stack)malloc(sizeof(T_Stack));
    ret->stk = (int*)malloc(sizeof(int) * capacity);
    ret->stkSize = 0;
    ret->stkCapcaity = capacity;
    return ret;
}

/* 入栈操作 */
void stackPush(PT_Stack obj, int element) {
    obj->stk[obj->stkSize++] = element;
}

/* 出栈操作 */
void stackPop(PT_Stack obj) {
    obj->stkSize--;
}

/* 获得栈顶元素 */
int satckTop(PT_Stack obj) {
    return obj->stk[obj->stkSize - 1];
}

/* 判断栈是否为空 */
int stackEmpty(PT_Stack obj) {
    return obj->stkSize == 0;
}

/* 释放栈的内存空间 */
void satckFree(PT_Stack obj) {
    free(obj->stk);
}

/* 构造队列；使用两个栈 */
typedef struct MyQueue{
    PT_Stack inStack;
    PT_Stack outSatck;
}MyQueue, *PT_MyQueue;

/** Initialize your data structure here. */
PT_MyQueue myQueueCreate() {
    PT_MyQueue ret  = (PT_MyQueue)malloc(sizeof(MyQueue));
    ret->inStack    = stackCreate(100);
    ret->outSatck   = stackCreate(100);
    return ret;
}

/* 入栈向出栈传值 */
void in2out(MyQueue* obj) {
    while(!stackEmpty(obj->inStack)) {
        stackPush(obj->outSatck, satckTop(obj->inStack));
        stackPop(obj->inStack);
    }
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    stackPush(obj->inStack, x);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    if (stackEmpty(obj->outSatck)) {
        in2out(obj);
    }
    int x = satckTop(obj->outSatck);
    stackPop(obj->outSatck);
    return x;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    if (stackEmpty(obj->outSatck)) {
        in2out(obj);
    }
    return satckTop(obj->outSatck);
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return stackEmpty(obj->inStack) && stackEmpty(obj->outSatck);
}

void myQueueFree(MyQueue* obj) {
    satckFree(obj->inStack);
    satckFree(obj->outSatck);
}

/**
 * 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);
 */

3、队列实现栈

leetcode 225. 用队列实现栈

leetcode 225. 用队列实现栈
使用队列实现栈的下列操作：

• push(x) – 元素 x 入栈
• pop() – 移除栈顶元素
• top() – 获取栈顶元素
• empty() – 返回栈是否为空

注意:

• 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
• 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
• 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

使用两个队列实现栈：
C语言代码如下：

/* 构造队列结构 */
#define LEN 20
typedef struct queue {
    int* data;
    int head;
    int rear;
    int size;
} Queue;

/* 初始化队列 */
Queue* initQueue(int k) {
    Queue* obj = (Queue*)malloc(sizeof(Queue));
    obj->data = (int*)malloc(sizeof(int) * k);
    obj->head = -1;
    obj->rear = -1;
    obj->size = k;
    return obj;
}

/* 入队列操作 */
void enQueue(Queue* obj, int e) {
    /* 若队列为空，则将队列头部置为0 */
    if (obj->head == -1) {
        obj->head = 0;
    }
    /* 队列尾部自加1，将元素存入队列尾部 */
    obj->rear = (obj->rear + 1) % obj->size;
    obj->data[obj->rear] = e;
}

/* 出队列操作 */
int deQueue(Queue* obj) {
    /* 将队列头部元素记录下来 */
    int a = obj->data[obj->head];
    /* 若队列只有一个元素，将头尾指针置为-1 */
    if (obj->head == obj->rear) {
        obj->head = -1;
        obj->rear = -1;
        return a;
    }
    /* 队列不止一个元素，将头部后移一位即可 */
    obj->head = (obj->head + 1) % obj->size;
    return a;
}

/* 判断队列是否为空 */
bool isEmpty(Queue* obj) {
    return obj->head == -1;
}

/* 栈为两个队列模拟 */
typedef struct {
    Queue *queue1, *queue2;
} MyStack;

/** Initialize your data structure here. */
MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    obj->queue1 = initQueue(LEN);
    obj->queue2 = initQueue(LEN);
    return obj;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    /* 若queue1为空，将新元素放入queue2中，否则放入队列1中 */
    if (isEmpty(obj->queue1)) {
        enQueue(obj->queue2, x);
    } else {
        enQueue(obj->queue1, x);
    }
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    /* 若queue1中没有元素，将queue2中的元素出队列，
     * 移入queue1，留下queue2得队尾元素Pop即可
     */
    if (isEmpty(obj->queue1)) {
        while(obj->queue2->head != obj->queue2->rear) {
            enQueue(obj->queue1, deQueue(obj->queue2));
        }
        return deQueue(obj->queue2);
    }
    /* 若queue1中有元素，将queue1中的元素出队列，
     * 移入queue2，留下queue1得队尾元素Pop即可
     */
    while (obj->queue1->head != obj->queue1->rear) {
        enQueue(obj->queue2, deQueue(obj->queue1));
    }
    return deQueue(obj->queue1);
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    /* queue1为空，返回queue2得队尾元素 */
    if (isEmpty(obj->queue1)) {
        return obj->queue2->data[obj->queue2->rear];
    }
    return obj->queue1->data[obj->queue1->rear];
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    if (obj->queue1->head == -1 && obj->queue2->head == -1) {
        return true;
    }
    return false;
}

void myStackFree(MyStack* obj) {
    free(obj->queue1->data);
    obj->queue1->data = NULL;
    free(obj->queue1);
    obj->queue1 = NULL;
    free(obj->queue2->data);
    obj->queue2->data = NULL;
    free(obj->queue2);
    obj->queue2 = NULL;
    free(obj);
    obj = NULL;
}
/**
 * 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);
 */

4、栈的应用

leetcode 20.有效的括号

leetcode 20.有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

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

先来分析一下 这里有三种不匹配的情况：

• 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
  
• 第二种情况，括号没有多余，但是 括号的类型没有匹配上
  
• 第三种情况，字符串里右方向的括号多余了，所以不匹配
  
• 第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false
• 第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false
• 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false
• 那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

C语言代码实现：

bool isValid(char * s){
    char* stack = (char*)calloc(10000, sizeof(char));
    int i = 0, size = -1;
    while (i < strlen(s)) {
        if (s[i] == '(') {
            stack[++size] = ')';
        } else if (s[i] == '[') {
            stack[++size] = ']';
        } else if (s[i] == '{') {
            stack[++size] = '}';
        } else if (size == -1 || stack[size] != s[i]) {
            /* 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，
             * 说明右括号没有找到对应的左括号 return false
             */
            /* 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。
             * 所以return false
             */
            return false;
        } else {
            size--;
        }
        i++;
    }
    /* 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，
     * 说明有相应的左括号没有右括号来匹配，所以return false，
     * 否则就return true
     */
    return size == -1;
}

leetcode 1047. 删除字符串中的所有相邻重复项

leetcode 1047. 删除字符串中的所有相邻重复项
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例： 输入：“abbaca” 输出：“ca” 解释： 例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

提示： 1 <= S.length <= 20000 S 仅由小写英文字母组成。

使用栈进行匹配，C语言代码如下：

char * removeDuplicates(char * S){
    char* stack = (char*)calloc(strlen(S) + 1, sizeof(char));
    int size = -1;
    for (int i = 0; i < strlen(S); i++) {
        if (size == -1) {
            stack[++size] = S[i];
            continue;
        }
        if (stack[size] == S[i]) {
            size--;
            continue;
        }
        stack[++size] = S[i]; 
    }
    stack[++size] = '\0';
    return stack;
}

leetcode 150. 逆波兰表达式求值

leetcode 150. 逆波兰表达式求值
根据 逆波兰表示法，求表达式的值。

有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

• 示例 1： 输入: [“2”, “1”, “+”, “3”, " * "] 输出: 9 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
• 示例 2： 输入: [“4”, “13”, “5”, “/”, “+”] 输出: 6 解释: 该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
• 示例 3： 输入: [“10”, “6”, “9”, “3”, “+”, “-11”, " * ", “/”, " * ", “17”, “+”, “5”, “+”] 输出: 22 解释: 该算式转化为常见的中缀算术表达式为： ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 = ((10 * (6 / (12 * -11))) + 17) + 5 = ((10 * (6 / -132)) + 17) + 5 = ((10 * 0) + 17) + 5 = (0 + 17) + 5 = 17 + 5 = 22

逆波兰表达式：是一种后缀表达式，所谓后缀就是指算符写在后面。
平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。

使用栈来实现，遇到数组就入栈，遇到字符就判断并进行相应操作
C语言代码如下：

bool isNumber(char* token) {
    return strlen(token) > 1 || ('0' <= token[0] && token[0] <= '9');
}

int evalRPN(char ** tokens, int tokensSize) {
    int* stack = (int*)calloc(tokensSize, sizeof(int));
    int size = -1;
    for (int i = 0; i < tokensSize; i++) {
        char* token = tokens[i];
        int ret = 0;
        /* 判断为数字就入栈 */
        if (isNumber(tokens[i])) {
        	/* 将字符串转为整数int */
            stack[++size] = atoi(tokens[i]);
            continue;
        }
		/* 遇到符号就进行计算 */
        if (token[0] == '+') {
            ret = stack[size - 1] + stack[size];
            stack[--size] = ret;
            continue;
        } else if (token[0]== '-') {
            ret = stack[size - 1] - stack[size];
            stack[--size] = ret;
            continue;
        } else if (token[0] == '*') {
            ret = stack[size - 1] * stack[size];
            stack[--size] = ret;
            continue;
        } else if (token[0] == '/') {
            ret = stack[size - 1] / stack[size];
            stack[--size] = ret;
            continue;
        }
    }
    return stack[size];
}

5、队列的应用

leetcode 239. 滑动窗口最大值

leetcode 239. 滑动窗口最大值
给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。

C语言代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize){
    /* 使用数组来模拟队列 */
    int queue[numsSize];
    int left = 0, right = 0;
    /* 将前k个元素按照单调减的顺序入队列 */
    for (int i = 0; i < k; i++) {
        /* 若当前元素比队列右边的元素大，则right减小到当前元素比队列元素小的第一个位置 */
        while(left < right && nums[i] > nums[queue[right - 1]]) {
            right--;
        }
        queue[right++] = i;
    }
    /* 返回数组的大小为numsSize - k + 1 */
    int* ret = (int*)calloc(numsSize - k + 1, sizeof(int));
    *returnSize = 0;
    ret[(*returnSize)++] = nums[queue[left]];
    for (int i = k; i < numsSize; i++) {
        /* 若当前元素比队列右边的元素大，则right减小到当前元素比队列元素小的第一个位置 */
        while(left < right && nums[i] > nums[queue[right - 1]]) {
            right--;
        }
        /* 存入新数据 */
        queue[right++] = i;
        /* 判断当前队列的最大元素是否在i-k-1 到i中；
         * 若不在，则left要右移到i-k-1的位置
         */
        while(queue[left] <= i - k) {
            left++;
        }
        ret[(*returnSize)++] = nums[queue[left]];
    }
    return ret;
}

C++代码如下：

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
        // 同时pop之前判断队列当前是否为空。
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);

        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front() {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};

leetcode 347.前 K 个高频元素

leetcode 347.前 K 个高频元素

参考 代码随想录 的讲解,使用队列实现一个堆

我使用结构体实现的堆，C语言代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
/* 堆中的数据结构体 */
typedef struct pair {
    int key;
    int value;
}T_pair, *PT_pair;

/* 堆的结构体 */
typedef struct Heap {
    PT_pair data;
    int szie;
    int capacity;
}T_Heap, *PT_Heap;

/* 哈希表结构体 */
typedef struct hash_table {
    int key;
    int value;
    UT_hash_handle hh;
}T_hash_table, *PT_hash_table;

/* 交换 */
void swap(PT_pair a, PT_pair b) {
    int tmp1 = a->key;
    int tmp2 = a->value;

    a->key = b->key;
    a->value = b->value;

    b->key = tmp1;
    b->value = tmp2;
}

/* 从堆下层向上交换元素，使得堆为小根堆 */
void swim(PT_pair nums, int k) {
    while (k > 1 && nums[k].value < nums[k / 2].value) {
        swap(&nums[k], &nums[k / 2]);
        k /= 2;
    }
}

/* 从堆上层向下层交换元素，使得堆为小根堆 */
void sink(PT_pair nums, int k, int numsSize) {
    while (2 * k <= numsSize) {
        int child = 2 * k;
        if (child < numsSize && nums[child].value > nums[child + 1].value) {
            child++;
        }
        if (nums[k].value < nums[child].value) {
            break;
        }
        swap(&nums[k], &nums[child]);
        k = child;
    }
}

/* 初始化一个堆 */
PT_Heap createHeap(int k) {
    PT_Heap obj = (PT_Heap)malloc(sizeof(T_Heap));
    obj->data = (PT_pair)malloc(sizeof(T_pair) * (k + 1));
    obj->szie = 0;
    obj->capacity = k + 1;
    return obj;
}

/* 判断堆是否为空 */
bool isEmpty(PT_Heap obj) {
    return obj->szie == 0;
}

/* 获得堆的当前大小 */
int getHeapSize(PT_Heap obj) {
    return obj->szie;
}

/* 将元素入堆 */
void pushHeap(PT_Heap obj, PT_hash_table elem) {
    /* 新加入的元素放入堆的最后 */
    obj->data[++obj->szie].key = elem->key;
    obj->data[obj->szie].value = elem->value;
    /* 对当前堆进行排序,使其成为一个大根堆 */
    swim(obj->data, obj->szie);
}

/* 获得堆顶元素 */
PT_pair getHeapTop(PT_Heap obj) {
    return &obj->data[1];
}

/* 将堆顶元素出堆 */
PT_pair popHeap(PT_Heap obj) {
    /* 保存堆顶元素 */
    PT_pair top = (PT_pair)malloc(sizeof(T_pair));  // = &obj->data[1];
    top->key = obj->data[1].key;
    top->value = obj->data[1].value;
    /* 将堆顶元素和堆底元素交换,同时堆长度减一 */
    swap(&obj->data[1], &obj->data[obj->szie--]);
    /* 将原先的堆底元素赋值为INT_MIN */
    obj->data[obj->szie + 1].key = 0;
    obj->data[obj->szie + 1].value = 0;
    /* 从堆顶开始重新堆化 */
    sink(obj->data, 1, obj->szie);
    return top;
}

int* topKFrequent(int* nums, int numsSize, int k, int* returnSize){
    /* 定义哈希表，用来存储元素出现频率 */
    PT_hash_table hash = NULL;
    /* 遍历输入数组，记录其元素及其频率的映射 */
    for (int i = 0; i < numsSize; i++) {
        PT_hash_table p;
        HASH_FIND_INT(hash, &nums[i], p);
        if (p == NULL) {
            p = (PT_hash_table)malloc(sizeof(T_hash_table));
            p->key = nums[i];
            p->value = 1;
            HASH_ADD_INT(hash, key, p);
        } else {
            p->value++;
        }
    }
    /* 初始化一个大小为k的堆 */
    PT_Heap heap = createHeap(k);
    /* 将频率数组堆化 */
    for (PT_hash_table tmp = hash; tmp != NULL; tmp = tmp->hh.next) {
        if (getHeapSize(heap) == k) {
            PT_pair tmp1 = getHeapTop(heap);
            if (tmp->value > tmp1->value) {
                popHeap(heap);
                pushHeap(heap, tmp);
            }
        } else {
            pushHeap(heap, tmp);
        }
    }
    /* 返回数组长度为k */
    int* res = (int*)calloc(k, sizeof(int));
    *returnSize = k;
    /* 将堆中元素传入返回数组 */
    for (int i = 0; i < k; i++) {
        PT_pair tmp = popHeap(heap);
        res[i] = tmp->key;
    }
    return res;
}

C++代码如下：

// 时间复杂度：O(nlogk)
// 空间复杂度：O(n)
class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒叙来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};

上一节：5、双指针相关

下一节：7、二叉树相关