广联达校招笔试复盘：C++指针与数据结构重难点解析

每年九月一到，校招笔试的通知就像秋天的落叶一样密集。我印象里2018年那一轮广联达的笔试，整体难度不算顶尖，但题量大、覆盖面广、细节抠得深，尤其C++指针和数据结构那两块，刷掉的人不在少数。广联达是建筑信息化领域的头部公司，涉及造价、BIM、施工管理等业务，开发岗位以C++和Java为主，岗位说明里频繁出现“图形引擎”“海量构件数据处理”“云端协同”这些词。笔试题目也确实是朝着这个方向使劲的：基础语法细到让人怀疑人生，算法题则务实到可以直接在业务里看到影子。这篇文章就按我当时刷完题、复盘完的感受来写，把整套题的考察逻辑、典型题目、答题思路和踩坑点全部掰开揉碎讲清楚。如果你正准备投广联达，或者在做其他公司的校招笔试题，这套复盘基本能覆盖大半考察范围。

1. 先摸清底细：广联达校招笔试到底在考什么

1.1 岗位画像：开发工程师在广联达要干啥

很多人看到广联达的第一反应是“造价软件”，这个印象不算错，但它的业务盘子比想象中大得多。除了传统的造价算量软件，后面又延伸出BIM三维建模、施工项目管理云平台、企业级数据协同系统，甚至还有IoT设备和图形算法相关的底层模块。这些业务有一个共同特点：既要处理海量的结构化数据，又要在复杂业务规则下做高性能计算，再加上大量桌面端和移动端交互界面，开发工程师的日常工作基本逃不开这几类问题。

这就决定了笔试的考察不是单纯背八股，而是看你有没有能力写出“能扛住真实业务压力”的代码。比如C++指针考得深，是因为桌面端图形引擎和算量引擎多数是C++写的，指针用不好，崩一次就可能拖垮整个模块；Java考察并发和集合原理，是因为云端服务要面对大量用户同时访问；数据库SQL考得多，是因为造价和施工数据动辄百万级记录，随便一个慢查询都可能让用户原地爆炸。

所以备考广联达，先别急着刷一堆偏题怪题，要把重点放在计算机基础的主干知识上。笔试刷人的核心逻辑非常朴素：基础不牢，后面的技术面试就算聊得再好，也容易让人觉得是空中楼阁。

1.2 试卷结构：四类题型的出题逻辑与分值分布

广联达2018校招开发工程师的笔试，我拿到的这套是线上笔试，总时长大约90分钟，总分100分，题型分四块。这四块的分布逻辑跟很多大厂不太一样，它不搞“智力题开场”那套，而是直接进入技术主题，时间紧张的时候非常考验临场心态。

常考的题型和大致分值如下：

单选和多选覆盖的知识点非常密集，基本是按照“语言基础—数据结构—操作系统—网络—数据库”的节奏往下铺。编程题不会特别难，不考红黑树手写、不考AC自动机这类劝退题，但会在边界条件上埋雷，比如空指针、数组越界、溢出、重复元素等，稍不注意就丢分。

我后来复盘时最大的感受是：这套题不是要你打满分，而是要你在有限时间内稳稳拿住基础分，编程题尽量通过全部测试用例。很多人挂在中间，不是因为题不会，而是因为前面选择题纠结太久，编程题根本没时间写完整。后面我会专门讲时间分配，这里先提一句：单道选择题如果30秒内没头绪，先标记跳过，别恋战。

2. 重灾区解析：数组与指针笔试题，做错的人最多

2.1 两道必考的指针经典题，现场拆解

C/C++指针与数组那几道题，是我和身边同学公认的“重灾区”。它不像Java那样帮你把内存管得死死的，一个指针操作不当就是段错误，所以笔试里特别喜欢出这类题考察基本功。

第一道非常典型：

#include <stdio.h> void foo(int arr[10]) { printf("%d\n", sizeof(arr) / sizeof(arr[0])); } int main() { int a[10]; printf("%d\n", sizeof(a) / sizeof(a[0])); foo(a); return 0; }

问两个printf分别输出什么。如果你在main函数里写出sizeof(a)/sizeof(a[0])，结果是10，这没问题。但foo函数里的arr，虽然是“int arr[10]”的样子，实际上在参数传递时会退化成int指针。所以foo函数里的sizeof(arr)是8，sizeof(arr[0])是4，结果是2。当年很多人栽在这一题上，因为忘了“数组作为函数参数会退化为指针”这个基础机制。

这道题背后真正想考的是：你有没有理解数组名和指针的区别，以及C语言编译时期sizeof的行为。说到底，sizeof是在编译期求值的，它只能拿到静态类型信息。main里a是“int[10]”，所以sizeof(a)是40字节；而foo里arr是“int*”，sizeof(arr)就是8字节（64位系统）或4字节（32位系统）。

第二道经典题是二维数组和指针的组合：

#include <stdio.h> int main() { int a[2][3] = {{1, 2, 3}, {4, 5, 6}}; int *p = (int *)a; printf("%d\n", *(p + 4)); printf("%d\n", *(a[1] + 1)); printf("%d\n", *(*(a + 1) + 2)); return 0; }

第一问：p被强转为int指针，指向a的起始地址，a在内存里连续存放，所以*(p+4)就是第4个元素，即a[0][3]其实越界到了a[1][0]，数值是4。第二问：a[1]是第二行的数组名，等价于指向第二行首元素的指针，所以a[1]+1指向5，输出5。第三问：a+1指向第二行（类型是int()[3]），(a+1)拿到第二行首地址，再加2后解引用，指向a[1][2]，输出6。

这种题看似绕，实际只要搞清“a是什么类型”“a[1]是什么类型”“指针加N移动多少字节”三层关系，基本不会错。我的建议是笔试前把下面这张表记牢，考场直接套：

• a：整个二维数组的首地址，类型是int(*)[3]
• &a：整个二维数组的地址，类型是int(*)[2][3]
• a[0]：第一行数组名，类型是int*
• a[0][0]：第一行第一个元素
• a+1：跳过一整行，指向第二行

2.2 数组名与指针的区别，一句话讲透

很多同学会觉得“数组名就是指针”，这句话在80%场景下没错，但笔试就爱考那20%的边界。准确说法是：数组名在大多数表达式中会隐式转换为指向首元素的指针，但在两种情况下不会，一是作为sizeof的操作数，二是作为&操作数的操作数。

举个例子：

char str1[] = "hello"; char *str2 = "hello";

str1是一个字符数组，可以修改内容；str2是一个指针，指向字符串字面量，写str2[0] = 'H'在C++里是未定义行为，很大概率崩溃。笔试里如果问“两者有什么不同”，既要答内存分布位置（str1在栈上，字面量通常在只读区），也要答sizeof的结果不同（str1是6，包含结尾的\0；str2是8或4，取决于系统位数）。

还有一道衍生题也很常见：int arr[5]; int *p = arr;，问p++和arr++的区别。p++合法，p指向下一个元素；arr++非法，因为数组名不是可变左值，不能被赋值。这个考点本身不难，但结合自增运算和优先级，就能衍生出*(p++)、(*p)++等一堆变体，稍不留神就踩坑。

我自己的经验是：指针题不要靠心算，拿笔画一下内存布局，把每个变量的地址、类型、偏移量写出来再推。尤其是二维数组和函数传参的题，画图效率比空想高得多。

2.3 内存对齐和指针运算，知道原理就不慌

广联达这套题里有道关于结构体大小的题，也属于高频错题：

struct A { char a; int b; char c; }; struct B { char a; char b; int c; };

问sizeof(struct A)和sizeof(struct B)分别是多少。在64位Linux默认对齐规则下，两者都是12字节。但如果你把结构体成员顺序换一下，结果可能完全不同。A是1+4+1，中间为了对齐int，a后面补3字节，c后面按最大对齐数4补齐3字节，总计1+3+4+1+3=12；B是1+1+2+4=8。这个对比说明，结构体成员排列顺序会影响内存占用，写代码时调整成员顺序就能省空间。

光知道结论还不够，要理解对齐规则：结构体每个成员的起始地址必须能被自身大小整除，结构体总大小必须能被最大成员大小整除。这是C/C++的硬性规则，笔试题不会要求你背标准条文，但会用这种题测试你有没有踩过内存布局的坑。

指针运算有个容易混淆的点：ptr+1到底加了多少字节，取决于ptr指向的类型大小。例如int *p加1，实际地址增加4字节；char *p加1，增加1字节；void *p在标准C里是不允许直接做算术运算的，有些编译器把它当作1字节处理，但这属于未定义或扩展行为，笔试答案按标准走。

我当时复盘时给自己定了一条原则：凡是遇到指针偏移的填空，先把“目标类型字节数”写出来，再乘偏移量，不要凭感觉。这样虽然慢一点，但准确率极高。

3. Java程序题与语言细节，考验的是扎实功底

3.1 String、equals和哈希的隐性考点

Java方向的笔试题不会只考概念，而是把常见坑包装成程序输出题。最经典的是String那组：

public class StringTest { public static void main(String[] args) { String s1 = "hello"; String s2 = "hello"; String s3 = new String("hello"); String s4 = s3.intern(); System.out.println(s1 == s2); System.out.println(s1 == s3); System.out.println(s1 == s4); System.out.println(s1.equals(s3)); } }

输出结果是true、false、true、true。这里考察的是字符串常量池的概念：直接赋值时，如果常量池已有相同内容，就复用同一个对象，所以s1和s2指向同一地址；new String一定创建新对象，所以s1和s3不相等；intern方法会尝试把字符串加入常量池并返回常量池引用，所以s1和s4相同；equals比较的是内容，所以最后为true。

这道题看起来简单，但能延伸出很多问题。比如重写equals时必须重写hashCode，原因在于HashMap、HashSet这类集合先计算hashCode定位桶，再用equals判断元素是否相等。如果两个对象equals相等但hashCode不同，集合里就会出现重复元素，这是实际开发里很隐蔽的bug。广联达笔试不一定直接让你写一段代码，但如果前面出现“关于hashCode和equals，下列说法正确的是”这类选项，坑就埋在这里。

3.2 线程并发题怎么答才拿分

Java多线程在笔试题里的出现频率非常高，尤其是synchronized、volatile、ThreadLocal、线程池状态这些概念。常见的选择题会问：“关于volatile，下列说法正确的是？”正确项往往是“保证可见性，不保证原子性”，错误项则经常写着“保证原子性”或“可以替代synchronized”。

如果试卷里出现代码输出题，可能会考synchronized加在静态方法和实例方法上有什么区别。静态方法锁的是Class对象，实例方法锁的是this对象，两者不是同一把锁，所以可以在并发场景下同时执行。这类题目不复杂，但需要你理解“锁的对象是谁”这个核心。

还有一道容易出错的题是i++线程安全问题。代码里定义了一个共享变量int count = 0，然后开两个线程分别执行count++一万次，问最终结果是否为20000。正确回答是不一定小于等于20000，原因是count++包含读、加、写三步，线程A和线程B可能同时读到旧值，导致写回时互相覆盖。分析的时候不仅要答结果，还要说清楚为什么，最好能提到“原子性”“内存可见性”“指令重排序”这三个层次。

我当时备考的感触是，Java并发题最怕“背结论”。你只有理解了synchronized是互斥锁、volatile是轻量级同步机制、AtomicInteger是靠CAS实现原子性，才能真正应对题目变化。广联达这类公司业务里有大量云端并发访问场景，并发基础扎实的人在简历筛选和后续面试里都会更有优势。

4. 数据结构与算法，笔试里的“分水岭”

4.1 链表和二叉树的高频题，必须能默写

广联达2018这套笔试题的编程题里，有一道是“反转单链表”，这几乎是校招必考题。基础版本要求迭代实现，进阶版本要求递归实现。迭代写法很简单：

public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode curr = head; while (curr != null) { ListNode next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; }

递归写法更能体现思维深度：

public ListNode reverseList(ListNode head) { if (head == null || head.next == null) { return head; } ListNode newHead = reverseList(head.next); head.next.next = head; head.next = null; return newHead; }

笔试里如果你写出了递归版本，建议再补一句“递归调用栈深度和链表长度成正比，超长链表可能导致栈溢出，所以工程上更推荐迭代实现”。这样不仅代码写对了，还能展示工程意识，技术面试官会非常喜欢。

二叉树的高频题是“层次遍历”，要求按层输出节点值。核心思路是借助队列，每轮循环先记录当前队列大小，再逐个出队并放入下一层节点。有些公司在笔试里会要求用“之字形”遍历，也就是奇数层从左到右、偶数层从右到左，这时候可以通过记录层号并在输出结果时逆序来实现。这些都是leetcode中等偏下难度的题目，但很能反映基本功是否扎实。

4.2 动态规划和贪心的典型题，思路比代码重要

动态规划在广联达笔试中通常不会出太难的中等题，但会出现“最长公共子序列”“最大子数组和”这类经典模型。这里我拿“最大子数组和”举例，题目是给定一个整数数组，找到一个具有最大和的连续子数组，返回其最大和。

动态规划解法如下：

public int maxSubArray(int[] nums) { int curMax = nums[0]; int globalMax = nums[0]; for (int i = 1; i < nums.length; i++) { curMax = Math.max(nums[i], curMax + nums[i]); globalMax = Math.max(globalMax, curMax); } return globalMax; }

核心思想是：以当前位置结尾的最大子数组和，要么是当前元素自己，要么是“前一个位置结尾的最大子数组和”加上当前元素。这里面“状态定义”和“状态转移方程”是解题关键，代码本身不过几行。笔试答题时建议先写清楚状态定义，再写转移方程，最后附代码，这样即使代码有小bug，阅卷人也容易给你过程分。

贪心题目里常考“跳跃游戏”，判断能否跳到最后一个位置。思路是维护一个最远可达位置，遍历过程中不断更新，如果当前下标超过最远可达位置就直接返回false。这类题目做多了之后你会发现，判断“能不能”的问题多数可以用贪心或BFS，判断“有多少种”的问题则优先考虑动态规划。

4.3 手写代码时的常见失误，全是我踩过的坑

编程题最容易翻车的不是思路，而是细节。第一，数组边界。比如二分查找里left + right可能溢出，应该写成left + (right - left) / 2；第二，空指针。链表操作如果没有判断head == null，一上来就访问head.next，轻则编译报错，重则运行崩溃；第三，循环终止条件。双指针题里如果没想清楚是while (left <= right)还是while (left < right)，很容易死循环或漏掉元素。

还有个很现实的坑是“本地跑得通，线上超时”。笔试平台一般会限制时间复杂度和内存，如果你用了Arrays.sort之后又来一层O(n^2)遍历，大数据量下必然超时。所以手写代码前，先想清楚复杂度：输入规模是10^5量级，O(n^2)基本必挂，至少要想到O(n log n)或O(n)的解法。

我自己的习惯是，拿到题目先不急着写，花2分钟把输入规模、时间限制、边界条件、返回值类型写在草稿纸上，然后写一个暴力版本，再考虑优化。这样做的好处是，即使最终没写出最优解法，至少保证暴力版能通过部分测试用例，不至于零分。

5. Linux、数据库与网络：非主语言岗位最容易翻车的板块

5.1 Linux必考命令与排查思路，背熟这几条就够用

广联达的笔试里Linux题不是大块头，但单选和填空里都会出现。常见考点包括：查看端口占用用什么命令（netstat -tlnp或ss -tlnp）、实时查看日志（tail -f）、查找文件内容（grep）、统计文本行数（wc -l）、修改文件权限（chmod）、查看进程（ps -ef）。

有时候会给你一个描述，让你选最合适的命令组合。比如：“程序运行异常，需要查看最近100行日志并持续追踪新日志”，答案就是tail -100f app.log。这里一个常见的坑是，有人只写tail -100 app.log，丢掉了f，就不能持续追踪。虽然命令本身合法，但不符合题目描述的场景。

如果题目让你“统计access.log中每个IP出现次数并返回前10”，完整命令是：

awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10

这条命令考察了awk取列、sort排序、uniq去重统计、head取前N行，属于Linux笔试题里比较综合的题型。笔试现场如果时间充裕，建议把每个命令的作用注释在旁边，这样可以争取到简答题的步骤分。

5.2 SQL题：从“会查”到“查得对”

数据库题在广联达笔试里几乎年年出现，而且更偏向实际使用，比如连表查询、分组统计、去重排序。典型题目是：表student有字段id、name、score，查询每个班级的最高分。这里的关键是把“每个班级”转成“按class_id分组”，再用MAX(score)取最高分：

SELECT class_id, MAX(score) AS max_score FROM student GROUP BY class_id;

进阶版本是“查询成绩高于班级平均分的学生名单”，这时候必须用子查询或窗口函数。笔试通常允许两种写法，但如果你用了窗口函数，记得考虑平台版本是否支持。更稳妥的写法是关联子查询：

SELECT s1.id, s1.name, s1.score, s1.class_id FROM student s1 WHERE s1.score > ( SELECT AVG(s2.score) FROM student s2 WHERE s2.class_id = s1.class_id );

笔试里SQL题最容易错的是join类型混淆：inner join只返回两表匹配的行，left join返回左表全部行，right join返回右表全部行，full outer join返回两表全部行。如果在多选题里看到“哪个j oin会保留左表中没有匹配的记录”，答案就是left join和full outer join，漏选或错选的概率很大。

5.3 TCP三次握手和HTTP的追问套路，别再只会背流程

网络题在选择题里通常不会太难，但会在简答题里出现。最经典的是“为什么TCP连接需要三次握手，而不是两次或四次”。直接回答“确保双方收发能力正常”只能说对了一半，更完整的说法是：两次握手无法避免已经失效的连接请求报文段突然又传到服务端，导致服务端误以为客户端要建立连接而白等；四次握手则多余，因为客户端收到服务端的SYN+ACK后，双方已经明确对方收发能力正常，不需要再增加一次往返。

HTTP题的常见考法是“从输入网址到页面展示，中间经历了什么”，这个综合题考察DNS解析、TCP连接、HTTP请求、Nginx转发、应用处理、数据库查询、响应返回等全链路。广联达偏业务系统开发，这类分析题很能体现你是否具有整体视角。回答时按层次展开即可：先DNS拿到IP，再TCP三次握手，然后浏览器发送HTTP请求，服务器处理并返回响应，浏览器解析渲染。

还有一个容易问到的点是HTTP与HTTPS的区别。老套的答案是“HTTPS多了一层SSL/TLS加密”，但高级一点的回答要补充：HTTPS默认端口443，HTTP是80；HTTPS在传输层之上增加了加密握手过程，可以防止中间人窃听和篡改；但对服务器有额外的性能开销。笔试如果只是选择题，选项里出现“HTTPS可以完美防止DDoS攻击”这类绝对化表述，基本就是错误项。

6. 实战编程题全流程演示：从读题到通过样例

6.1 一题多用：数组里找出现次数超过一半的数

这道题在广联达2018校招笔试里我印象很深，因为它是“换了个包装的多数元素问题”。题目描述：给定一个长度为n的数组，其中有一个数字出现次数超过n/2，找出这个数字。如果不存在，返回-1。

最容易想到的是先排序，然后返回中位数，复杂度O(n log n)。更优解是Boyer-Moore投票算法，时间复杂度O(n)，空间复杂度O(1)。核心思路是维护一个候选数和计数器，遇到相同数字加一，遇到不同数字减一，计数器归零时更换候选数。候选数不一定就是答案，因为题目没有保证一定存在，所以最后还要再遍历一次统计候选数出现次数。

public int majorityElement(int[] nums) { int candidate = nums[0]; int count = 1; for (int i = 1; i < nums.length; i++) { if (count == 0) { candidate = nums[i]; count = 1; } else if (nums[i] == candidate) { count++; } else { count--; } } // verify int cnt = 0; for (int num : nums) { if (num == candidate) { cnt++; } } return cnt > nums.length / 2 ? candidate : -1; }

我为什么强调“最后还要再遍历一次”？因为如果没有保证一定存在，只靠投票算法会误判。实际笔试平台的测试用例一定会包含“不存在多数元素”的边界case，这一步不做验证，就会挂掉一部分用例。这道题也经常被追问“如果数组长度的定义是long类型怎么办”，这时候就需要考虑计数变量用long。

6.2 手写LRU缓存，怎么在40分钟内不慌

LRU（Least Recently Used，最近最少使用）是一道高频编程题，广联达当年的笔试里以“设计一个支持get和put操作的LRU缓存结构”的形式出现，要求平均时间复杂度O(1)。实现方法并不唯一，最简单的方案是使用LinkedHashMap，Java里自带有序Map，但面试官通常希望看到手写“双向链表+HashMap”的版本。

核心数据结构是HashMap存储key到链表节点的映射，双向链表维护访问顺序。每次访问key时，把对应节点移动到链表头部；每次插入key时，如果容量已满，删除链表尾部节点，再插入新节点到头部。双向链表是为了实现O(1)的节点删除和移动，单链表做不到。

class DLinkedNode { int key; int value; DLinkedNode prev; DLinkedNode next; } class LRUCache { private Map<Integer, DLinkedNode> cache = new HashMap<>(); private int capacity; private DLinkedNode head, tail; public LRUCache(int capacity) { this.capacity = capacity; head = new DLinkedNode(); tail = new DLinkedNode(); head.next = tail; tail.prev = head; } public int get(int key) { DLinkedNode node = cache.get(key); if (node == null) return -1; moveToHead(node); return node.value; } public void put(int key, int value) { DLinkedNode node = cache.get(key); if (node != null) { node.value = value; moveToHead(node); } else { DLinkedNode newNode = new DLinkedNode(); newNode.key = key; newNode.value = value; cache.put(key, newNode); addToHead(newNode); if (cache.size() > capacity) { DLinkedNode tailNode = removeTail(); cache.remove(tailNode.key); } } } }

这类题在笔试里拉分差距很大，因为它不只考链表操作，还考map和链表的联动。我的建议是平时把“删除节点”“移动到头部”“添加到头部”“删除尾部”这四个基础操作单独封装成函数，考试时反复调用，不容易写乱。写完代码之后，一定要走一遍测试：先put(1,1)、put(2,2)，再get(1)，然后再put(3,3)，看看被淘汰的是不是key=2。如果淘汰错了，说明“最近最少使用”这个语义没实现正确。

6.3 现场调试的技巧，没有IDE也能快速验证

线上笔试平台一般不会给你完整的本地IDE调试环境，最多提供一个在线编辑器和运行按钮。这时候最怕的是代码写完了，一运行发现编译错误，但错误提示信息很粗糙，定位半天找不到问题。我总结了一套快速自查流程。

第一步，先看编译错误。如果平台提示“找不到符号”，优先检查变量名是否拼写一致、类名是否和文件名一致、是否导入了需要的包。第二步，如果运行超时，先把循环里的输出去掉，或者检查是否出现了死循环，重点看while循环的结束条件。第三步，如果结果不对，在最容易出错的位置加System.err或print输出调试信息，比如链表节点移动后打印每个节点的key，数组下标边界打印i和j的值。笔试平台一般允许输出调试信息，提交前记得删掉即可。

还有个小技巧：本地没有编译器时，用可视化数据流的方法代替调试器。手动模拟一次输入，把每一步变量的变化用纸笔记下来，看是否与预期一致。这个方法在处理链表和动态规划题时特别管用，能避免写出“逻辑看起来对但实际执行不对”的代码。

7. 备考经验与踩坑实录

7.1 刷题之外的准备：项目经历和技术深度不能瘸腿

笔试只是校招的第一关，但笔试成绩直接影响后续面试官对你的初始印象。广联达的面试官会拿着你的笔试卷子，挑几道错题重点问，所以笔试复盘不能只对答案，还要把每道错题背后涉及的知识点理顺。我当时就把错题分成了“知识点盲区”和“粗心失误”两类，盲区用半天时间集中补，粗心失误则在下一轮刷题中刻意放慢读题速度。

项目经历在笔试中不会直接加分，但会影响你后续的面试走向。广联达比较看重工程实践能力，简历上有真实项目、能讲清楚技术选型和性能优化细节的候选人，面试时明显更有优势。如果你现在还只是刷题，没有拿得出手的项目，建议至少做一个小工具，比如一个带Web界面的数据查询系统，用上MySQL、Redis、Spring Boot这些主流技术栈，能覆盖简历上的多数技术名词。

7.2 时间分配与心理建设：90分钟其实非常紧张

90分钟做完整套笔试题，平均一道客观题只有不到2分钟，编程题需要留至少35分钟。我当时的策略是：先花5分钟快速浏览一遍整套卷子，标记出“完全不会”的题和“能稳拿”的题，然后从客观题往后做，遇到卡的题直接跳到下一道。编程题放在最后，但一定保证至少留出30分钟给第一道编程题，因为编程题解决一道就比客观题拿分效率高得多。

心理上也要有预期：题目大概率是做不完的。广联达那套卷子的阅读量和代码量，即便是基础知识很扎实的候选人，也很难每题都仔细检查。笔试考察的是你在紧张状态下的决策能力，能把会做的做对、不会的果断放弃，就已经跑赢很多人。

7.3 那些年我见过的真实失误与教训

最后分享几个我亲眼见过或自己踩过的真实失误，希望能帮你避坑。

第一，有人因为忘带头文件导致编译失败。笔试平台不是本地的完整IDE，不会自动引入所有标准库。使用vector要先#include <vector>，使用HashMap要import java.util.*。第二，有人写SQL时没有在语句末尾加分号，平台明明是允许的，但有些答题框会把SQL作为多行文本提交，少分号就少了几分。第三，有人在编程题里开了一个超过内存限制的大数组，比如int[1000000]在Java里没问题，但如果写成int[10000000]，堆内存可能直接溢出，平台直接判Runtime Error。

还有一个小建议：笔试前一天不要熬夜刷题，保持精神状态正常比多做几道题更重要。笔试过程中如果遇到不会的题，深呼吸，先把能拿的分拿到，不要因为一道题卡住就影响整场心态。我自己经历过几次校招笔试后最大的体会是，技术基础决定了你的下限，答题策略和临场心态决定了你的上限。广联达这套题覆盖的知识点范围很广，但只要把计算机基础的主干知识复习扎实，再加上适量的专项刷题，通过笔试并不是可望不可即的事。