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 + * 也可以依据次序计算出正确结果。
-
适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> stk;
for (int i = 0; i < tokens.size(); i++) {
if (tokens[i] != "+" && tokens[i] != "-" && tokens[i] != "*" &&
tokens[i] != "/") {
stk.push(stoi(tokens[i]));
} else if (tokens[i] == "+") {
int tmp1 = stk.top();
stk.pop();
int tmp2 = stk.top();
stk.pop();
stk.push(tmp1 + tmp2);
} else if (tokens[i] == "-") {
int tmp1 = stk.top();
stk.pop();
int tmp2 = stk.top();
stk.pop();
stk.push(tmp2 - tmp1);
} else if (tokens[i] == "*") {
int tmp1 = stk.top();
stk.pop();
int tmp2 = stk.top();
stk.pop();
stk.push(tmp1 * tmp2);
} else if (tokens[i] == "/") {
int tmp1 = stk.top();
stk.pop();
int tmp2 = stk.top();
stk.pop();
stk.push(tmp2/tmp1);
}
}
return stk.top();
}
};
239. 滑动窗口最大值
给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。
进阶：
你能在线性时间复杂度内解决此题吗？
</div>
提示：
-
1 <= nums.length <= 10^5
-
-10^4 <= nums[i] <= 10^4
-
1 <= k <= nums.length
使用deque最为合适，在文章栈与队列：来看看栈和队列不为人知的一面中，我们就提到了常用的queue在没有指定容器的情况下，deque就是默认底层容器。
基于刚刚说过的单调队列pop和push的规则，代码不难实现，如下：
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();
}
};
这样我们就用deque实现了一个单调队列，接下来解决滑动窗口最大值的问题就很简单了，直接看代码吧。
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;
}
};
-
时间复杂度: O(n)
-
空间复杂度: O(k)
再来看一下时间复杂度，使用单调队列的时间复杂度是 O(n)。
有的同学可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的O(n)。
其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。
空间复杂度因为我们定义一个辅助队列，所以是O(k)。
347.前 K 个高频元素(拓展)
这种题往往离不开大顶堆和小顶堆
笨方法：nlog(n)
class Solution {
public:
vector<int> topKFrequent(vector<int>& nums, int k) {
// 使用 unordered_map 记录每个元素的频率
unordered_map<int, int> freq_map;
for (int num : nums) {
freq_map[num]++;
}
// 将 map 的键值对提取到 vector 中
vector<pair<int, int>> vec(freq_map.begin(), freq_map.end());
// 按照值的降序对 vector 中的键值对进行排序
sort(vec.begin(), vec.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
return a.second > b.second;
});
// 取出前 k 个频率最高的元素
vector<int> result;
for (int i = 0; i < k; i++) {
result.push_back(vec[i].first);
}
return result;
}
};
优先队列（Priority Queue）是一种抽象数据类型，类似于队列（Queue），但与普通队列不同的是，每个元素都有一个与之关联的优先级。优先队列中的元素按照优先级的顺序进行插入和删除操作，通常支持高优先级元素先出队的规则。
特点和操作
-
优先级规则
：
-
元素可以根据某个优先级进行排列，常见的情况是数字越大表示优先级越高（大顶堆），或者数字越小表示优先级越高（小顶堆）。
-
-
主要操作
：
-
插入（Insert）：将新元素插入到优先队列中，根据元素的优先级确定其位置。
-
删除最高优先级元素（Delete-Max or Delete-Min）：从优先队列中删除具有最高优先级的元素。
-
查看最高优先级元素（Find-Max or Find-Min）：获取优先队列中具有最高优先级的元素，但不删除它。
-
实现方式
优先队列可以使用多种数据结构实现，最常见的有：
-
二叉堆（Binary Heap）：通过完全二叉树实现，分为大顶堆和小顶堆。
-
斐波那契堆（Fibonacci Heap）：在某些操作上性能更优，但实现复杂度高。
-
配对堆（Pairing Heap）：较为简单的一种实现方式，效率介于二叉堆和斐波那契堆之间。
大顶堆（Max Heap）和小顶堆（Min Heap）是堆（Heap）数据结构的两种形式，它们在算法和数据结构中有着广泛的应用，主要用于动态地维护一组数据中的最大值或最小值。
堆（Heap）概述
堆是一种特殊的树形数据结构，它满足以下两个性质：
-
结构性质：堆是一个完全二叉树（Complete Binary Tree），即除了最后一层，其它层的节点都是满的，且最后一层的节点集中在左侧。
-
堆序性质：对于大顶堆，父节点的值始终大于或等于其子节点的值；对于小顶堆，父节点的值始终小于或等于其子节点的值。
大顶堆（Max Heap）
在大顶堆中，每个父节点的值都大于或等于其子节点的值。换句话说，堆中的最大元素总是位于根节点（堆顶），因此大顶堆也称为最大堆。
-
特性：
-
根节点是堆中的最大元素。
-
任意节点的值都大于等于其子节点的值。
-
-
操作：
-
插入操作：将新元素插入到堆的末尾，然后通过上移操作（percolate up）将其调整到合适的位置，以维持堆的性质。
-
删除操作：删除堆顶元素后，将堆的最后一个元素移动到堆顶，然后通过下移操作（percolate down）将其调整到合适的位置，以维持堆的性质。
-
-
应用：
-
实现优先队列（Priority Queue）：可以快速访问和删除最大元素。
-
堆排序（Heap Sort）：利用堆的特性实现的一种排序算法。
-
小顶堆（Min Heap）
在小顶堆中，每个父节点的值都小于或等于其子节点的值。堆中的最小元素位于根节点（堆顶），因此小顶堆也称为最小堆。
-
特性：
-
根节点是堆中的最小元素。
-
任意节点的值都小于等于其子节点的值。
-
-
操作：
-
插入操作：将新元素插入到堆的末尾，然后通过上移操作将其调整到合适的位置。
-
删除操作：删除堆顶元素后，将堆的最后一个元素移动到堆顶，然后通过下移操作将其调整到合适的位置。
-
-
应用：
-
实现优先队列（Priority Queue）：可以快速访问和删除最小元素。
-
实现图论算法中的 Dijkstra 算法和 Prim 算法。
-
哈夫曼树（Huffman Tree）是一种用于数据压缩的树形数据结构，它利用字符出现频率来构建一种最优的前缀编码。哈夫曼树主要用于哈夫曼编码（Huffman Coding），这是一种变长编码（Variable-Length Code），其中出现频率高的字符用较短的编码，而出现频率低的字符用较长的编码，以达到压缩数据的目的。
构建哈夫曼树的步骤
构建哈夫曼树的基本思路是：
-
频率统计：统计需要编码的字符（或符号）在数据中出现的频率。
-
构建最小堆：将所有字符看作是一个森林（每个字符作为一个单独的树），按照它们的频率构建一个最小堆（Min Heap）。堆中的每个节点都是一个树。
-
合并最小频率的树：从堆中选择两个具有最小频率的树（节点），合并它们成为一棵新的树。新树的根节点频率为两个子树根节点频率之和。
-
重复步骤3：重复上述步骤，直到堆中只剩下一棵树为止。这棵树即为哈夫曼树。
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1:
-
输入: nums = [1,1,1,2,2,3], k = 2
-
输出: [1,2]
示例 2:
-
输入: nums = [1], k = 1
-
输出: [1]
提示：
-
你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
-
你的算法的时间复杂度必须优于 $O(n \log n)$ , n 是数组的大小。
-
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
-
你可以按任意顺序返回答案。
什么是堆呢？
堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。
本题我们就要使用优先级队列来对部分频率进行排序。
为什么不用快排呢， 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。
此时要思考一下，是使用小顶堆呢，还是大顶堆？
有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。
那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。
而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？
所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。
寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）
我们来看一下C++代码：
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;
}
};
-
时间复杂度: O(nlogk)
-
空间复杂度: O(n)
扫一扫
9676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
