C++数据结构与算法机试代码大全

1. 项目背景与核心价值

作为一名经历过考研复试机试的过来人，我深知数据结构与算法在计算机相关专业复试中的关键地位。机试环节往往要求在有限时间内完成多道编程题目的解答，这不仅考察基础知识的掌握程度，更考验实际编码能力和解题思维。而C++作为算法竞赛和高校机试的主流语言，其高效性和丰富的STL库使其成为应对这类场景的利器。

这个代码大全的诞生，源于我当年备战期间踩过的无数坑。市面上虽然不缺算法教程，但要么偏重理论推导缺乏代码实现，要么代码示例过于零散不成体系。特别是在高压的机试环境下，如何快速定位到所需算法的标准实现模板，并针对题目特点进行适当修改，成为决定成败的关键技能。

2. 内容架构设计思路

2.1 知识体系划分

本代码大全采用"数据结构+算法+题型"三维分类法：

• 线性结构：数组、链表、栈、队列、字符串
• 树形结构：二叉树、BST、AVL、堆、并查集
• 图结构：邻接矩阵、邻接表、遍历算法、最短路径
• 经典算法：排序、查找、分治、贪心、动态规划
• 特殊题型：大数运算、数学问题、位运算技巧

2.2 代码呈现规范

每个算法模块遵循统一模板：

cpp复制// 算法描述与复杂度分析
// 输入输出说明
// 典型应用场景提示

#include <bits/stdc++.h>
using namespace std;

// 核心实现代码
void algorithm(...) {
    // 关键步骤注释
}

// 测试用例
int main() {
    // 标准测试案例
    // 边界条件测试
    return 0;
}

特别注意：机试环境通常允许使用<bits/stdc++.h>头文件，但实际工程中应避免

3. 核心数据结构实现精要

3.1 动态数组高效操作

cpp复制// 动态数组处理技巧
vector<int> arr;

// 预分配空间避免频繁扩容
arr.reserve(1000); 

// 原地去重（需先排序）
sort(arr.begin(), arr.end());
arr.erase(unique(arr.begin(), arr.end()), arr.end());

// 二维数组定义
vector<vector<int>> matrix(m, vector<int>(n, 0));

3.2 链表常规模板

cpp复制struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 快慢指针找中点
ListNode* findMid(ListNode* head) {
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

3.3 二叉树遍历统一写法

cpp复制// 非递归前序遍历
vector<int> preorderTraversal(TreeNode* root) {
    vector<int> res;
    stack<TreeNode*> st;
    if (root) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top(); st.pop();
        res.push_back(node->val);
        if (node->right) st.push(node->right);
        if (node->left) st.push(node->left);
    }
    return res;
}

4. 关键算法实现解析

4.1 快速排序优化版本

cpp复制void quickSort(vector<int>& nums, int l, int r) {
    if (l >= r) return;
    
    // 三数取中法选择基准值
    int mid = l + (r - l) / 2;
    if (nums[l] > nums[r]) swap(nums[l], nums[r]);
    if (nums[mid] > nums[r]) swap(nums[mid], nums[r]);
    if (nums[l] < nums[mid]) swap(nums[l], nums[mid]);
    
    int pivot = nums[l];
    int i = l, j = r;
    while (i < j) {
        while (i < j && nums[j] >= pivot) j--;
        nums[i] = nums[j];
        while (i < j && nums[i] <= pivot) i++;
        nums[j] = nums[i];
    }
    nums[i] = pivot;
    
    quickSort(nums, l, i - 1);
    quickSort(nums, i + 1, r);
}

4.2 Dijkstra最短路径算法

cpp复制vector<int> dijkstra(vector<vector<pair<int, int>>>& graph, int start) {
    int n = graph.size();
    vector<int> dist(n, INT_MAX);
    dist[start] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.emplace(0, start);
    
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue;
        for (auto [v, w] : graph[u]) {
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.emplace(dist[v], v);
            }
        }
    }
    return dist;
}

5. 机试专项技巧

5.1 输入输出加速

cpp复制// 关闭同步流提速（慎用，会影响cin/cout与scanf/printf混用）
ios::sync_with_stdio(false);
cin.tie(nullptr);

// 快速读取整数
inline int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

5.2 常见问题处理模式

大数取模运算：

cpp复制// 防止中间结果溢出
long long mul_mod(long long a, long long b, long long mod) {
    long long res = 0;
    a %= mod;
    while (b) {
        if (b & 1) res = (res + a) % mod;
        a = (a << 1) % mod;
        b >>= 1;
    }
    return res;
}

滑动窗口模板：

cpp复制int slidingWindow(vector<int>& nums, int k) {
    int left = 0, res = 0;
    unordered_map<int, int> count;
    
    for (int right = 0; right < nums.size(); right++) {
        count[nums[right]]++;
        while (count.size() > k) {
            if (--count[nums[left]] == 0)
                count.erase(nums[left]);
            left++;
        }
        res = max(res, right - left + 1);
    }
    return res;
}

6. 实战调试技巧

6.1 常见错误排查

1. 段错误(Segmentation Fault)

   • 检查数组越界访问
   • 验证指针是否为nullptr
   • 递归深度是否导致栈溢出

2. 时间限制 exceeded

   • 检查算法时间复杂度是否合适
   • 避免不必要的嵌套循环
   • 使用更高效的数据结构

3. 内存限制 exceeded

   • 检查是否有内存泄漏
   • 评估数据结构规模是否合理
   • 考虑使用更紧凑的数据表示

6.2 调试代码模板

cpp复制#ifdef DEBUG
#define debug(x) cerr << #x << " = " << x << endl
#else
#define debug(x)
#endif

// 在代码中插入调试点
debug(variable_name);

// 编译时添加-DDEBUG参数启用调试输出

7. 典型题目代码实现

7.1 二叉树序列化与反序列化

cpp复制class Codec {
public:
    string serialize(TreeNode* root) {
        if (!root) return "#";
        return to_string(root->val) + "," + 
               serialize(root->left) + "," +
               serialize(root->right);
    }

    TreeNode* deserialize(string data) {
        queue<string> q;
        stringstream ss(data);
        string item;
        while (getline(ss, item, ',')) q.push(item);
        return helper(q);
    }
    
private:
    TreeNode* helper(queue<string>& q) {
        string val = q.front(); q.pop();
        if (val == "#") return nullptr;
        TreeNode* node = new TreeNode(stoi(val));
        node->left = helper(q);
        node->right = helper(q);
        return node;
    }
};

7.2 LRU缓存实现

cpp复制class LRUCache {
private:
    int capacity;
    list<pair<int, int>> cache;
    unordered_map<int, list<pair<int, int>>::iterator> map;
    
public:
    LRUCache(int capacity) : capacity(capacity) {}
    
    int get(int key) {
        if (!map.count(key)) return -1;
        auto it = map[key];
        cache.splice(cache.begin(), cache, it);
        return it->second;
    }
    
    void put(int key, int value) {
        if (map.count(key)) {
            auto it = map[key];
            it->second = value;
            cache.splice(cache.begin(), cache, it);
            return;
        }
        if (cache.size() == capacity) {
            map.erase(cache.back().first);
            cache.pop_back();
        }
        cache.emplace_front(key, value);
        map[key] = cache.begin();
    }
};

8. 性能优化策略

8.1 空间换时间技巧

1. 预处理技术：

   • 预先计算阶乘、素数表等常用数据
   • 使用前缀和数组加速区间查询

2. 记忆化搜索：

   cpp复制unordered_map<string, int> memo;
   
   int dfs(string state) {
       if (memo.count(state)) return memo[state];
       // 计算过程...
       return memo[state] = res;
   }
   

3. 位运算优化：

   cpp复制// 判断是否为2的幂次
   bool isPowerOfTwo(int n) {
       return n > 0 && (n & (n - 1)) == 0;
   }
   

8.2 STL高效使用

1. 优先队列自定义比较：

   cpp复制auto cmp = [](const pair<int, int>& a, const pair<int, int>& b) {
       return a.second > b.second; // 小顶堆
   };
   priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> pq(cmp);
   

2. 有序集合应用：

   cpp复制set<int> s;
   // 查找第一个大于等于x的元素
   auto it = s.lower_bound(x);
   if (it != s.end()) cout << *it;
   

3. 哈希表优化：

   cpp复制unordered_map<int, int> countMap;
   countMap.reserve(10000); // 预分配空间减少rehash
   

9. 机试应试策略

9.1 时间分配建议

1. 5分钟审题：

   • 明确输入输出格式
   • 识别题目考察的核心算法
   • 预估数据规模和时间复杂度

2. 15分钟编码：

   • 套用标准模板快速实现
   • 添加必要注释
   • 处理边界条件

3. 5分钟测试：

   • 常规测试用例
   • 极端情况测试（空输入、最大值等）
   • 随机数据测试

9.2 代码风格建议

1. 模块化编程：

   cpp复制// 将功能拆分为独立函数
   void solve() {
       input();
       process();
       output();
   }
   

2. 防御性编程：

   cpp复制// 检查输入合法性
   if (n <= 0) {
       cout << 0 << endl;
       return;
   }
   

3. 注释规范：

   cpp复制/* 
    * 功能：计算两个区间的交集
    * 参数：a1,a2 - 第一个区间端点
    *      b1,b2 - 第二个区间端点
    * 返回：交集的长度，无交集返回0
    */
   int intervalIntersect(int a1, int a2, int b1, int b2) {
       // 实现代码...
   }
   

10. 进阶学习建议

1. 在线判题平台：

   • LeetCode（题型全面）
   • 牛客网（国内高校真题）
   • Codeforces（算法竞赛向）

2. 参考书籍：

   • 《算法导论》（理论基础）
   • 《挑战程序设计竞赛》（实战技巧）
   • 《STL源码剖析》（C++底层实现）

3. 调试工具：

   • GDB调试器（Linux环境）
   • Visual Studio调试功能（Windows）
   • 在线IDE的调试功能（如LeetCode Playground）

在实际机试准备过程中，建议每天保持3-5道中等难度题目的训练量，重点不是刷题数量，而是每道题都能彻底理解并能够快速实现。对于常考的高频题型（如二叉树遍历、动态规划、图算法等），要准备2-3种不同实现方式的代码模板，以应对不同约束条件下的题目要求。