Learning Record

have done

assignment

class template

An excellent programmer only needs to know how to use containers to improve program encapsulation and reduce coupling, without understanding the underlying principles

Deque

在C++中，deque（双端队列）是一种容器，支持在两端进行高效地插入和删除操作。以下是deque常用的操作：

头部和尾部元素操作：
- push_front(element): 在deque的头部插入一个元素。
- push_back(element): 在deque的尾部插入一个元素。
- pop_front(): 移除deque的头部元素。
- pop_back(): 移除deque的尾部元素。
- front(): 返回deque的头部元素的引用。
- back(): 返回deque的尾部元素的引用。
迭代器操作：
- begin(): 返回指向deque的第一个元素的迭代器。
- end(): 返回指向deque的最后一个元素之后位置的迭代器。
- rbegin(): 返回指向deque的最后一个元素的逆向迭代器（反向迭代器）。
- rend(): 返回指向deque的第一个元素之前位置的逆向迭代器。
容量操作：
- size(): 返回deque中元素的个数。
- empty(): 检查deque是否为空。
- resize(new_size): 改变deque的大小，如果new_size比当前大小小，则删除末尾元素；如果new_size比当前大小大，则在末尾插入默认构造的元素。
- max_size(): 返回deque能够容纳的最大元素数量。
访问元素操作：
- at(index): 返回指定索引处的元素的引用，带有边界检查。
- operator[](index): 访问指定索引处的元素的引用，不进行边界检查。
- front(): 返回deque的头部元素的引用。
- back(): 返回deque的尾部元素的引用。
清空和删除操作：
- clear(): 移除deque中的所有元素，使其为空。
- erase(position): 移除指定位置处的元素。
- erase(first, last): 移除指定范围内的元素。
- remove(value): 移除deque中所有等于给定值的元素。

这些是deque常用的操作，可以根据需要选择合适的操作来操作deque容器。

SET

插入操作：
- insert(value): 将一个元素插入set中。
- insert(first, last): 将一个范围内的元素插入set中。
- emplace(args...): 在set中构造一个元素。
- emplace_hint(hint, args...): 在给定提示位置处构造一个元素。
删除操作：
- erase(value): 从set中移除一个元素。
- erase(iterator): 从set中移除给定迭代器指向的元素。
- erase(first, last): 移除一个范围内的元素。
- clear(): 清空set中的所有元素。
查找操作：
- find(value): 查找一个特定的元素，并返回一个迭代器指向它。
- count(value): 返回set中等于给定值的元素的数量（因为set中元素是唯一的，所以结果要么是0，要么是1）。
- lower_bound(value): 返回一个迭代器指向第一个不小于给定值的元素。
- upper_bound(value): 返回一个迭代器指向第一个大于给定值的元素。
- equal_range(value): 返回一个pair对象，包含lower_bound和upper_bound的结果。
容量操作：
- size(): 返回set中元素的数量。
- empty(): 检查set是否为空。
迭代器操作：
- begin(): 返回指向set中第一个元素的迭代器。
- end(): 返回指向set中最后一个元素之后位置的迭代器。
- rbegin(): 返回指向set中最后一个元素的逆向迭代器（反向迭代器）。
- rend(): 返回指向set中第一个元素之前位置的逆向迭代器。

std::set还支持自动排序和去重的特性，确保元素始终按照升序排列，并且不允许重复元素存在。

这些是std::set常用的操作，可以根据需要选择合适的操作来操作set容器。

MAP

在C++中，std::map是一种关联容器，它以键-值对（key-value pair）的形式存储元素，并根据键进行排序和访问。以下是std::map常用的操作：

插入操作：
- insert({key, value}): 插入一个键-值对到map中。
- insert(make_pair(key, value)): 插入一个键-值对到map中。
- emplace(key, args...): 在map中构造一个键-值对。
- emplace_hint(hint, key, args...): 在给定提示位置处构造一个键-值对。
删除操作：
- erase(key): 移除指定键的键-值对。
- erase(iterator): 移除给定迭代器指向的键-值对。
- erase(first, last): 移除一个范围内的键-值对。
- clear(): 清空map中的所有键-值对。
查找操作：
- find(key): 查找一个特定的键，并返回一个迭代器指向它。
- count(key): 返回map中具有给定键的键-值对的数量（因为map中键是唯一的，所以结果要么是0，要么是1）。
- lower_bound(key): 返回一个迭代器指向第一个不小于给定键的键-值对。
- upper_bound(key): 返回一个迭代器指向第一个大于给定键的键-值对。
- equal_range(key): 返回一个pair对象，包含lower_bound和upper_bound的结果。
访问操作：
- at(key): 返回具有给定键的值的引用，如果键不存在，会抛出std::out_of_range异常。
- operator[](key): 访问具有给定键的值的引用，如果键不存在，则插入一个具有默认值的键-值对并返回该值的引用。
容量操作：
- size(): 返回map中键-值对的数量。
- empty(): 检查map是否为空。
迭代器操作：
- begin(): 返回指向map中第一个键-值对的迭代器。
- end(): 返回指向map中最后一个键-值对之后位置的迭代器。
- rbegin(): 返回指向map中最后一个键-值对的逆向迭代器（反向迭代器）。
- rend(): 返回指向map中第一个键-值对之前位置的逆向迭代器。

std::map以键进行排序，所以键的类型需要支持比较操作（或通过提供自定义比较函数对象来进行比较）。键是唯一的，每个键只能关联一个值。

这些是std::map常用的操作，可以根据需要选择合适的操作来操作map容器。

PAIR

在C++中，std::pair是一个模板类，用于存储两个值的有序对。std::pair常用于返回多个值或将多个值组合在一起。以下是std::pair的常用操作：

构造函数和赋值操作符：
- pair<T1, T2> p: 创建一个名为p的std::pair对象，其中T1和T2分别是第一个值和第二个值的类型，默认构造这两个值。
- pair<T1, T2> p(value1, value2): 创建一个名为p的std::pair对象，并用value1和value2初始化第一个值和第二个值。
- p1 = p2: 将一个std::pair对象赋值给另一个std::pair对象。
成员变量：
- p.first: 访问std::pair对象的第一个值。
- p.second: 访问std::pair对象的第二个值。
比较操作：
- p1 == p2: 比较两个std::pair对象是否相等，即第一个值和第二个值都相等。
- p1 != p2: 比较两个std::pair对象是否不相等。
- p1 < p2: 按字典序比较两个std::pair对象。首先比较第一个值，如果第一个值相等，则比较第二个值。
交换操作：
- swap(p1, p2): 交换两个std::pair对象的值。

std::pair提供了一种方便的方式来组合和操作两个值。它在许多标准库的函数和算法中被广泛使用，例如std::map、std::unordered_map等容器，以及在返回多个值的情况下。

Leecode/LOGO

239. 滑动窗口最大值 - 力扣（Leetcode）

优先级队列---虽然运行超时了但是用例都通过了菜鸡还是很开心的

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size(); // 先计算数组长度
        vector<int> ans;     // 接收结果

        priority_queue<pair<int,int>> ret;

        for(int i = 0; i < k; i++){ // 对于前k个元素
            ret.push(make_pair(nums[i],i));
        }

        ans.push_back(ret.top().first);

        for(int i = k; i < n; i++){
            while(ret.top().second <= i-k){
                ret.pop();
            }
            ret.push(make_pair(nums[i],i));
            ans.push_back(ret.top().first);
        }
        return ans;
    }
};