STL在LeetCode刷题中的高效应用与实战技巧

1. 为什么STL是LeetCode刷题的利器

作为一名从ACM竞赛转战互联网大厂面试的C++老手，我深刻体会到STL（Standard Template Library）在算法题中的战略价值。记得刚开始刷LeetCode时，我总喜欢手写各种排序和查找，直到某次面试被面试官反问"为什么不用STL的sort？"时才恍然大悟——合理利用STL不仅能提升编码效率，更是工程实践能力的体现。

STL的精髓在于它提供了经过工业级验证的高效组件。以sort函数为例，其底层采用introsort（内省排序）算法，会根据数据规模自动在快速排序、堆排序和插入排序间切换，时间复杂度稳定在O(nlogn)。这种优化程度远超大多数手写实现，更重要的是节省了宝贵的解题时间。

在Hot100这类高频题库中，约70%的题目都可以用STL简化实现。比如：

• 字符串处理：substr/find简化字符串操作
• 容器操作：vector的emplace_back比push_back更高效
• 算法模板：next_permutation直接解决全排列问题

关键认知：STL不是作弊工具，而是C++程序员必须掌握的"标准装备"。面试中合理使用STL反而会展现你的专业素养。

2. 必须烂熟于心的STL核心武器库

2.1 排序与元素操作三剑客

sort的进阶用法：

cpp复制// 基本排序
vector<int> nums = {3,1,4,2};
sort(nums.begin(), nums.end()); // 默认升序

// 自定义比较器
struct Point {
    int x, y;
};
vector<Point> points = {{1,2}, {3,1}};
sort(points.begin(), points.end(), [](const Point& a, const Point& b) {
    return a.x < b.x; // 按x升序
});

// 部分排序（TopK问题）
nth_element(nums.begin(), nums.begin()+3, nums.end()); // 使前4个元素是最小的

reverse的妙用：

cpp复制// 配合sort实现降序
sort(nums.begin(), nums.end());
reverse(nums.begin(), nums.end());

// 字符串反转
string s = "hello";
reverse(s.begin(), s.end()); // 变为"olleh"

max/min的特殊场景：

cpp复制// 多元素比较
int m = max({a, b, c}); // 需要initializer_list

// 自定义类型需重载<或提供比较器
struct Node {
    int val;
    bool operator<(const Node& other) const {
        return val < other.val;
    }
};
Node a{1}, b{2};
cout << max(a, b).val; // 输出2

2.2 迭代器与auto的黄金组合

现代C++的auto关键字彻底改变了我们使用迭代器的方式：

cpp复制vector<vector<int>> matrix;

// 传统方式（冗长易错）
for(vector<vector<int>>::iterator it = matrix.begin(); it != matrix.end(); ++it)

// 现代C++方式
for(auto row : matrix) { // 拷贝每一行
    for(auto num : row) {
        cout << num;
    }
}

// 需要修改时用引用
for(auto& row : matrix) {
    row.push_back(0);
}

经验之谈：在LeetCode中，99%的迭代场景都可以用range-based for+auto解决。但要注意：

1. 只读遍历用const auto&
2. 需要修改用auto&
3. 简单类型可直接auto

2.3 lambda表达式的实战技巧

Lambda是STL算法的灵魂伴侣，尤其在自定义比较逻辑时：

cpp复制// 基本形式
auto cmp = [](int a, int b) { return a > b; };
sort(nums.begin(), nums.end(), cmp);

// 捕获列表的用法
int threshold = 5;
auto filter = [threshold](int x) { return x > threshold; };
vector<int> big_nums;
copy_if(nums.begin(), nums.end(), back_inserter(big_nums), filter);

// 递归lambda（C++14+）
auto factorial = [](auto self, int n) -> int {
    return n <= 1 ? 1 : n * self(self, n-1);
};
cout << factorial(factorial, 5); // 输出120

常见应用场景：

• 自定义排序规则（如二维数组按第二维排序）
• 条件筛选（如找出满足特定条件的元素）
• 快速定义临时函数（如DFS中的访问逻辑）

3. 字符串处理的隐藏API

3.1 分割与拼接的高效做法

字符串分割（比手动处理更优雅）：

cpp复制string s = "a,b,c";
vector<string> tokens;

// 方法1：使用stringstream
stringstream ss(s);
string token;
while(getline(ss, token, ',')) {
    tokens.push_back(token);
}

// 方法2：C++17的string_view（无拷贝）
for(auto sv : s | ranges::views::split(',')) {
    tokens.emplace_back(sv.begin(), sv.end());
}

字符串拼接：

cpp复制vector<string> parts = {"a", "b", "c"};

// 低效做法（多次内存分配）
string result;
for(auto& s : parts) {
    result += s;
}

// 高效做法（预分配+join）
size_t total = 0;
for(auto& s : parts) total += s.size();
string result;
result.reserve(total);
for(auto& s : parts) result += s;

3.2 查找与替换的工程实践

cpp复制string text = "hello world";

// 查找
size_t pos = text.find("world");
if(pos != string::npos) {
    cout << "Found at " << pos;
}

// 替换
text.replace(6, 5, "cpp"); // "hello cpp"

// 正则表达式（C++11+）
regex pattern(R"(\d+)");
string s = "a1b2c3";
s = regex_replace(s, pattern, "[$0]"); // "a[1]b[2]c[3]"

4. 容器操作的性能陷阱与优化

4.1 vector的预留空间策略

cpp复制vector<int> nums;

// 错误示范：导致多次扩容
for(int i=0; i<1e6; ++i) {
    nums.push_back(i); // 可能触发多次内存重分配
}

// 正确做法
nums.reserve(1e6); // 一次性分配足够空间
for(int i=0; i<1e6; ++i) {
    nums.emplace_back(i); // 无额外拷贝
}

4.2 map/unordered_map的选择

cpp复制// map（红黑树实现，有序）
map<string, int> m1;
m1["a"] = 1; // O(logn)

// unordered_map（哈希表实现，更快）
unordered_map<string, int> m2;
m2["a"] = 1; // 平均O(1)

// 自定义哈希函数（C++17）
struct MyHash {
    size_t operator()(const pair<int,int>& p) const {
        return hash<int>()(p.first) ^ hash<int>()(p.second);
    }
};
unordered_map<pair<int,int>, int, MyHash> special_map;

性能实测：在LeetCode数据规模下（通常n<1e5），unordered_map比map快2-5倍。但要注意：

1. 需要有序遍历时必须用map
2. 自定义类型作为key时需要提供哈希函数

5. 典型题目中的STL应用实例

5.1 两数之和（哈希优化）

cpp复制vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> seen; // 值到索引的映射
    for(int i=0; i<nums.size(); ++i) {
        int complement = target - nums[i];
        if(seen.count(complement)) {
            return {seen[complement], i};
        }
        seen[nums[i]] = i;
    }
    return {};
}

5.2 合并区间（排序+贪心）

cpp复制vector<vector<int>> merge(vector<vector<int>>& intervals) {
    if(intervals.empty()) return {};
    
    // 按起点排序
    sort(intervals.begin(), intervals.end(), [](const auto& a, const auto& b){
        return a[0] < b[0];
    });
    
    vector<vector<int>> res;
    res.push_back(intervals[0]);
    
    for(int i=1; i<intervals.size(); ++i) {
        if(res.back()[1] >= intervals[i][0]) { // 重叠
            res.back()[1] = max(res.back()[1], intervals[i][1]); // 关键点
        } else {
            res.push_back(intervals[i]);
        }
    }
    return res;
}

5.3 全排列（next_permutation）

cpp复制vector<vector<int>> permute(vector<int>& nums) {
    vector<vector<int>> res;
    sort(nums.begin(), nums.end()); // 必须先排序
    do {
        res.push_back(nums);
    } while(next_permutation(nums.begin(), nums.end()));
    return res;
}

6. 调试与性能优化技巧

6.1 快速打印容器内容

cpp复制template<typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "[";
    for(auto it=v.begin(); it!=v.end(); ++it) {
        os << *it << (it+1!=v.end() ? ", " : "");
    }
    return os << "]";
}

// 使用示例
vector<int> test = {1,2,3};
cout << test; // 输出[1, 2, 3]

6.2 时间复杂度分析工具

cpp复制#include <chrono>

auto start = chrono::high_resolution_clock::now();
// 测试代码
auto end = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::microseconds>(end-start);
cout << "Time: " << duration.count() << "μs\n";

6.3 内存使用检查

cpp复制#include <sys/resource.h>

void show_memory() {
    struct rusage usage;
    getrusage(RUSAGE_SELF, &usage);
    cout << "Memory: " << usage.ru_maxrss << "KB\n";
}

7. 从刷题到工程实践的跨越

在真实项目中，STL的使用会更加复杂。比如：

• 线程安全：STL容器不是线程安全的，需要自行加锁
• 自定义分配器：优化特定场景的内存分配
• 移动语义：C++11后优先使用emplace系列函数

一个工程级的STL使用示例：

cpp复制class ThreadSafeMap {
    unordered_map<string, string> data_;
    mutable mutex mtx_;
public:
    void insert(const string& key, const string& value) {
        lock_guard<mutex> lock(mtx_);
        data_.emplace(key, value); // 使用emplace避免临时对象
    }
    
    optional<string> get(const string& key) const {
        lock_guard<mutex> lock(mtx_);
        if(auto it = data_.find(key); it != data_.end()) {
            return it->second;
        }
        return nullopt;
    }
};

刷题时培养的良好STL使用习惯，会让你在工程实践中事半功倍。记住：优秀的C++工程师不是能记住所有STL API的人，而是知道在什么场景下选择最合适的工具的人。