📅 发布时间：2026/6/19 22:28:36

2025/12/12 今天学的day5的lecode203和206

lecode 203

痛点：如果要删除的是头节点 (head) 怎么办？如果你写了单独的逻辑来处理头节点，代码会很丑。

神技：虚拟头节点 (Dummy Head)。

创建一个假的节点指向 head，这样所有节点就都可以按“非头节点”的逻辑处理了。

/**

Definition for singly-linked list.
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) {}

};
/
class Solution {
public:
ListNode removeElements(ListNode* head, int val) {
ListNode* flag=new ListNode(0);
flag->next=head;
ListNode* cur=flag;
while(cur->next!=nullptr){
if(cur->next->val==val){
ListNode* temp=cur->next;
cur->next=temp->next;
delete temp;
}
else //注意要加else，防止在if里处理后的下一位为空；
cur=cur->next;
}
head=flag->next;
delete flag;
return head;
}
};

lecode206
反转链表 (LeetCode 206)
地位：面试默写题 Top 1。如果你卡顿超过 1 分钟，面试官会认为你基础不牢。

口诀：双指针法 —— prev (前任), curr (现任), temp (备胎)。

存备胎 (temp = curr->next)

改指向 (curr->next = prev)

前任上位 (prev = curr)

现任跟上 (curr = temp)
/**

Definition for singly-linked list.
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) {}

};
/
class Solution {
public:
ListNode reverseList(ListNode* head) {
ListNode* pre=nullptr;
ListNode* temp=nullptr;
ListNode* cur=head;
while(cur!=nullptr){
temp=cur->next;
cur->next=pre;
pre=cur;
cur=temp;
```
 }return pre;
```
}
};

虚函数

include

using namespace std;

class Animal {
public:
// 1. 如果没有 virtual，输出就是 "Animal speak"
// 2. 加上 virtual，输出就是 "Cat meow"
virtual void speak() {
cout << "Animal speak" << endl;
}
};

class Cat : public Animal { //继承父类
public:
void speak() override { // override 表示我重写了基类的虚函数
cout << "Cat meow" << endl;
}
};

int main() {
Animal* p = new Cat(); // 父类指针指向子类对象
p->speak(); // 关键时刻！
return 0;
}

为什么析构函数必须是虚函数？
这是多态场景下最常见的内存泄漏原因。

场景：用父类指针删除子类对象。
class Base {
public:
// ~Base() { cout << "Base dtor" << endl; } // 错误写法！
virtual ~Base() { cout << "Base dtor" << endl; } // 正确写法
};

class Derived : public Base {
public:
~Derived() { cout << "Derived dtor" << endl; }
};

int main() {
Base* p = new Derived();
delete p; // 关键在这里！
}
如果 Base 析构函数不是 virtual：

编译器看到 p 是 Base* 类型，直接调用 Base::~Base()。

后果： Derived::~Derived() 根本不会被执行。如果 Derived 里 new 了内存，就泄露了。

如果 Base 析构函数是 virtual：

编译器通过 vptr 找到 vtable，发现析构函数是虚的，于是调用实际对象 (Derived) 的析构函数。

Derived 析构完后，会自动调用 Base 的析构函数。完美。
永远记住：写父类时，先把析构函数加上 virtual。

面试官可能会反将一军：“既然 virtual 这么好，为什么 C++ 不默认把所有类的析构函数都设为 virtual？”

答案：为了性能 (Performance)。

解释：

如果一个类很小（比如只有两个 int），且不打算被继承（比如 std::vector 或 std::string）。

如果强行加上 virtual，这个类就会多一个 vptr 指针（通常 8 字节）。

对于小对象，体积瞬间膨胀（可能翻倍），而且每次调用都要查表，得不偿失。