刷题刷到一定量之后，你会发现一个特别有意思的现象：力扣上几乎所有 C++ 题解，遇到链表、二叉树这类结构时，清一色都是ListNode* node = new ListNode(0);，再往后就是node->next = new ListNode(1);。看得多了你会下意识跟着写，可一旦停下来问一句“为什么不直接写ListNode node(0);呢？”，很多人会愣住。
这个问题我琢磨过很久，也踩过不少坑。它表面上是“指针怎么用”的语法问题，实际牵扯到 C++ 的类对象模型、对象生命周期、内存布局以及力扣判题环境的特点。搞懂它，你刷题时就不只是“会抄写法”，而是真的明白了这行代码在干什么。
1. 先弄明白：链表面试考的其实是“指针链接”，不是“节点本身”
1.1 链表和树这类数据结构，本质是“指针的世界”
力扣里最常见的节点定义长这样：
struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nullptr) {} ListNode(int x, ListNode *next) : val(x), next(next) {} };二叉树节点也类似，无非是把next换成left和right。你会发现一个关键点：这类结构里，节点和节点的关系不是“包含”关系，而是“指向”关系。next不是一个ListNode对象，而是一个ListNode*，也就是指向另一个节点的指针。
这正是链表和数组最根本的区别。数组在内存里是连续的一段空间，元素 A 旁边的就是元素 B，靠下标就能找到彼此。链表不是，节点 1 和节点 2 在物理内存上可能隔得很远，只能通过next这个“地址线索”找过去。没有指针，链表就是一堆孤立的节点，完全串不起来。
所以题目考察的“翻转链表”“合并有序链表”“检测环”，本质上都是在操作这些指针引用关系。你把某个节点的next指向另一个节点，实际做的是修改地址信息，而不是复制对象。理解了这一点，就能明白为什么题解里满屏都是->箭头，因为->是“解引用并访问成员”的操作，意思就是：沿着这条地址线索走过去，访问那个目标对象的成员。
1.2 为什么力扣题解“绝大多数”都用指针 + new
刷过力扣热题 100 里的链表、二叉树题就会发现，几乎所有题解都是这么开头的：先new一个节点，然后用指针去操作。这背后有两个层面的原因。
第一，题目本身给的数据结构就是指针链接的。你的函数签名是ListNode* reverseList(ListNode* head)，拿到手的是一个指针，往下传的、往返回的也都是指针。题目需要的“产物”是一条链，链的每个节点都必须动态存在，不能因为某个局部作用域结束就让节点析构消失。这就把你推向了堆上分配对象。
第二，题解作者想展示的是“算法逻辑”，不是“内存管理”。他们希望你关注的是指针怎么改、边界怎么处理，而不是new之后有没有delete。力扣判题只看输出结果，不检测内存泄漏，所以几乎所有题解都会省略释放操作，目的就是让代码保持最小可读形态。这种做法在严格工程规范里不算合格，但在刷题场景里是合理的取舍。
2. 为什么不用普通对象直接建节点？关键词是“生命周期”
2.1 栈对象会在作用域结束的那一刻自动析构
很多人刚学 C++ 时会觉得，指针又难写又容易错，直接用对象多省事：
ListNode node(1); ListNode node2(2); node.next = &node2; // 不行，因为 node2 随时可能被销毁问题出在生命周期上。ListNode node(1);创建的是一个栈上对象，它的生命周期被绑定在所在作用域。函数执行完、或者{}代码块一结束，这个对象立刻析构，内存被回收。但链表需要的是“节点创建之后能一直存在，直到整条链被处理完毕”。栈对象根本做不到这点。
看这个典型错误：
ListNode* createNode(int val) { ListNode node(val); return &node; // 悬垂指针！ }函数返回时，node已经析构，你返回的地址指向的是一块已经失效的内存。后面访问->val，实际上是未定义行为，可能拿到垃圾值，更可能直接崩溃。这种问题一旦出现，排查起来非常痛苦，因为它不一定每次都会崩溃，表现很随机。
2.2 值传递的拷贝陷阱：对象拷贝了，链接关系没拷贝
退一步说，就算你用一个 vector 存节点，再通过下标访问，最后还是要用&vec[i]拿到节点的地址来串链表。而且 vector 扩容会导致元素迁移，你之前拿到的&vec[i]全部失效。如果你用嵌套结构来“值模拟”链表，比如定义一个包含两个子节点的父结构，那递归下去，每个节点都要包含后续所有节点，根本无法终止。
再想想值传递的问题。C++ 里ListNode node2 = node1;是浅拷贝，val被复制了，但next指针依然指向node1原本指向的节点。两个对象的next指向同一块内存，如果其中一个对象析构了，另一个的指针就成了悬垂指针。链表、树这类结构天然存在复杂引用关系，用值语义管理它们会带来无穷无尽的拷贝和失联问题。
2.3 有一个例外：dummy node 就可以不用 new
不过题解里有一个非常常见的反例：哑节点（dummy node）。比如合并有序链表、删除指定节点时，经常看到这种写法：
ListNode dummy(0); ListNode* cur = &dummy; while (...) { cur->next = new ListNode(...); cur = cur->next; } return dummy.next;这里的dummy就是栈上对象，没有用new。为什么它可以不用？因为dummy的生命周期是整个函数，它不需要活到函数返回之后，也没有人试图返回它的地址。它只是在函数内部作为一个“临时的起点”，供cur指针来回移动。凡是不需要被函数外部引用的节点，都可以用栈对象；凡是需要跨作用域存在、被外部继续链接的节点，才必须用new。
判断标准就一条：这个对象是否需要在离开当前作用域之后继续存活？需要，就new；不需要，就栈上创建。
3. new 的背后：手动控制的堆生命周期和“不清理”的刷题哲学
3.1 new 到底替你做了哪两件事
想要彻底弄明白为什么用new，得看清楚new的完整动作。它其实做了两件事：先从堆上分配一块足够大小的内存，然后在这块内存上调用构造函数，完成对象的初始化。
这两步不能反过来。malloc只做第一步：分配内存，但不会调用构造函数，所以malloc出来的“节点”里val是随机值，next也是垃圾值，不能直接当作对象用。new把分配内存和构造对象绑在一起，一步到位，返回的是对象的指针。
与之相对地，delete会先调用析构函数，再释放内存。但在力扣场景下，绝大多数题解根本没有delete。这看起来像技术债，实际上跟判题机制有关：力扣每个测试用例都在独立进程里运行，就算你在代码里泄漏了几万个节点，进程退出后操作系统会把所有内存回收。你在判题环境里看不到任何负面影响。
所以我经常说，力扣的 C++ 代码天然带有一种“刷题模式”的写法：内存泄漏不影响正确性，所以你不用管；但你在面试里最好提一句“工程实现时这里需要释放内存”，证明你知道生产环境不是这样的。
3.2 不 delete 真的没问题吗？分场景看
刷题是没问题，但要注意几个例外。如果你在一道题里循环十万次，每次都new一个节点，又没有释放，那内存占用确实会线性上涨。虽然最终进程退出会回收，但在极端情况下，比如单个测试用例数据极大、循环极多，堆内存分配本身的开销也会拖慢程序。
new分配堆内存的速度比栈上创建对象慢一个数量级。栈分配只是改一下栈指针，堆分配需要走内存管理器的分配算法，还可能涉及系统调用。在力扣上，90% 的题你体会不到这个差距，但某些变态测试点，大量new可能成为效率瓶颈。
如果真的介意这点，有一个替代思路叫“数组模拟链表”，很多 ACM 选手特别爱用：
vector<ListNode> nodes(10005); int idx = 0;先用一个vector预分配好对象，然后要用新节点时，就取&nodes[idx++]，完全避开new。这种方式比new快，也因为对象生命周期由vector统一管理而不会泄漏。我实测过一些链表翻转、链表排序的题，用数组模拟可以把运行时间缩短 30% 左右。
3.3 什么时候 new 反而是累赘？
还有一个反向场景：你删除一个节点时，只改了指针链接，没有delete那个节点。这在力扣上很常见，比如删除链表倒数第 N 个节点，题解通常只是跳过那个节点：
prev->next = prev->next->next;被跳过的节点还残留在堆上，没有释放。这又是刷题模式下的取舍。如果要严格管理，你该先保存ListNode* toDelete = prev->next;，然后改链接，再delete toDelete;。但这样做题解要多三行代码，而且很容易让读者分心。所以你会发现，只要题目没有明确要求“释放内存”，几乎没人会在力扣答案里写delete。
说白了，new在刷题里的意义，不是让你体会内存管理的精细，而是让你获得一块能活到任意时刻、能跨函数传递、能被指针自由链接的对象。力扣的题目定义就是这样设计的，你只是顺着它来。
4. 关于指针和类对象的几个高频疑问
4.1 双指针、快慢指针里的“指针”和 new 出来的指针是一回事吗？
这是刷题新手最容易混淆的一个点。力扣热搜词里经常出现“双指针法”“快慢指针”，和这里的new指针完全不是同一个概念。
双指针里的“指针”，在数组题里通常是下标，比如int i = 0, j = n - 1;，它只是一个整数索引；在链表题里，则是真正的ListNode* slow = head; ListNode* fast = head;。但注意，快慢指针移动走的是slow = slow->next，是在“沿着既有链接移动”，并没有创建任何新节点。整个查找环的过程，从头到尾不需要new一个新对象。
所以你在力扣上会看到两类 “指针操作”：一类是“移动指针去遍历”，用现成节点的链接关系；另一类是“创建新节点去拼链”，用new分配新对象。它们只是共用“指针”这个名词，做的事情完全不同。做题时先把这两件事分开，代码思路会清晰很多。
4.2 智能指针能不能拿来刷题？为什么几乎没人用
既然每次都new又不管清理，那用unique_ptr或者shared_ptr自动管理不是更好吗？理论上是，实操中几乎没人这么干，原因有两点。
第一，题目给的节点定义是裸指针。ListNode内部的next必须是ListNode*，没法直接改成unique_ptr<ListNode>，否则你连题目的函数签名都对不上。你自己定义一个新结构当然可以，但那样和题目不匹配，还要多写很多代码。
第二，智能指针的额外开销和写法复杂度，对刷题没有收益。题解追求的是最短时间写出最直白逻辑，裸指针 + new 是最贴合的形态。智能指针适合生产环境，不适合算法竞赛。
如果你实在想练智能指针，可以自己写一个小项目，比如实现一个拥有完整 RAII 的链表，来体会make_unique、移动语义和析构函数的配合。这是很好的练习，但别把它塞进力扣题解里。
4.3 面试被问“为什么这么写”，怎么答才加分
面试的时候，这道题其实是一个很好的深入话题。你不能只说“题解都这么写”，要说清楚几个层次。
先说表层：链表的节点散落在内存里，必须用指针建立链接关系。然后说中间层：new创建的对象在堆上，生命周期不受作用域限制，能跨函数返回和传递。再说工程层：力扣判题不检查内存泄漏，所以刷题代码普遍不delete，但生产环境必须用 RAII、智能指针或手动delete来管理。最后可以主动提一句：内存管理是我在工程项目里一定会认真处理的，刷题里只是为了让解题过程更专注。
这样一套下来，面试官会觉得你既有理论深度，又熟悉生产实践，而不是只会背题解。
5. 实操结论与我的个人经验
刷了这么久，我自己总结出一条很朴素的规律：一旦你发现某个对象需要“在多个函数之间共享”，或者需要“在函数返回后继续存活”，那就必须把它放在堆上，用new创建；如果它只是函数内部的一个临时工具，那栈对象完全可以胜任。力扣里几乎所有节点都属于前者，所以你看到的题解才会清一色new。
我也踩过一次很尴尬的坑。有一次写树的层序遍历，我用局部queue<TreeNode*> q存指针，还觉得没问题，结果某个分支里把局部节点的地址塞进了q，函数一返回，q里全是悬垂指针，整个输出全乱套。后来我长记性了，所有入队出队的节点必须是有明确源头的堆对象，或者是从题目给的树里游走出来的节点，绝不自己动手创建栈上的假节点往里塞。
说了这么多，核心就一句话：力扣题解使用指针 + new 创建类对象，不是故作高深，而是链式数据结构本质上依赖指针链接，堆对象才能突破作用域限制获得足够的存活时间。至于内存管理是否严格，在判题环境下可以简化，在工程里则要另当别论。弄懂这层逻辑，你看代码的速度都会快一截。
