今日学习的文章和视频链接
203文章链接: link
203视频讲解链接: link
707文章链接: link
707视频讲解链接: link
206文章链接: link
206视频讲解链接: link
203 移除链表元素
看到题目第一想法
题目：
给你一个链表的头节点 head和一个整数 val，请你删除链表中所有满足 Node.val == val的节点，并返回 新的头节点 。
有如下想法：
本题是主要考察的是删除链表节点，感觉设置一个虚拟头节点会使删除的形式统一，而不会出现对删除头节点和其它节点的分布讨论。
看完代码随想录后的想法
代码随想录中提到了两种方法：
-
直接使用原来的链表来进行移除节点操作
-
设置一个虚拟头结点在进行移除节点操作
其中第一种方法的缺点是在单链表中移除头结点 和 移除其他节点的操作方式是不一样，其实在写代码的时候也会发现，需要单独写一段逻辑来处理移除头结点的情况。
而第二种方法可以使原链表的所有节点就都可以按照统一的方式进行移除。
实现过程中遇到的困难
切记不要直接移动头节点，这样会导致无法返回正确的链表结构，我们需要设置一个临时指针指向头节点，通过移动该指针完成对链表的删除。
ListNode* cur = dummyHead;
设置指针cur指向虚拟头节点
代码
直接使用原来的链表来进行移除节点操作：
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
// 删除头结点
while (head != NULL && head->val == val) {
// 注意这里不是if
ListNode* tmp = head;
head = head->next;
delete tmp;
}
// 删除非头结点
ListNode* cur = head;
while (cur != NULL && cur->next!= NULL) {
if (cur->next->val == val) {
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
} else {
cur = cur->next;
}
}
return head;
}
};
设置一个虚拟头结点在进行移除节点操作：
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
ListNode* cur = dummyHead;
while (cur->next != NULL) {
if(cur->next->val == val) {
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
} else {
cur = cur->next;
}
}
head = dummyHead->next;
delete dummyHead;
return head;
}
};
707 设计链表
看到题目第一想法
该题主要考察一些链表的常见操作（增、删、查）。
看完代码随想录后的想法
本题设计链表的五个接口：
- 获取链表第index个节点的数值
- 在链表的最前面插入一个节点
- 在链表的最后面插入一个节点
- 在链表第index个节点前面插入一个节点
- 删除链表的第index个节点
这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目
链表操作的两种方式：
- 直接使用原来的链表来进行操作
- 设置一个虚拟头结点在进行操作
实现过程中遇到的困难
本题无困难
代码
class MyLinkedList {
public:
//定义链表节点结构体
struct LinkedNode{
int val;
LinkedNode* next;
LinkedNode(int val):val(val),next(nullptr){
}
};
//初始化链表
MyLinkedList() {
_dummyHead = new LinkedNode(0);//定义一个虚拟头结点，而不是真正的链表头结点
_size = 0;
}
int get(int index) {
if (index >(_size - 1)||index < 0){
return -1;
}
LinkedNode* cur = _dummyHead->next;
while(index--){
cur = cur->next;
}
return cur->val;
}
void addAtHead(int val) {
LinkedNode* newNode = new LinkedNode(val);
newNode->next = _dummyHead->next;
_dummyHead->next = newNode;
_size++;
}
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cur = cur->next;
}
cur->next = newNode;
_size++;
}
void addAtIndex(int index, int val) {
if (index > _size || index < 0){
return;
}
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(index--){
cur = cur->next;
}
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
void deleteAtIndex(int index) {
if (index >= _size||index < 0){
return;
}
LinkedNode* cur = _dummyHead;
while(index--){
cur = cur->next;
}
LinkedNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
_size--;
}
//打印链表
void printLinkedList(){
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cout<<cur->next->val<<" ";
cur = cur->next;
}
cout<<endl;
}
private:
int _size;
LinkedNode* _dummyHead;
};
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/
206 反转链表
看到题目第一想法
题目描述：
给你单链表的头节点 head，请你反转链表，并返回反转后的链表。
看到本题之后，想到通过改变链表的next指针指向来完成链表反转。
看完代码随想录后的想法
代码随想录里使用两种方法来完成链表的指针指向的翻转。
- 双指针法
- 递归法
两者逻辑相同，都是当cur为空时循环结束，不断将cur指向pre的过程。
双指针思路：
首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。
然后开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。
保存这个节点是因为接下来要改变 cur->next 的指向，将cur->next 指向pre ，此时已经反转了第一个节点了。
接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。
最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时return pre指针就可以了，pre指针就指向了新的头结点。
实现过程中遇到的困难
对递归法理解还不够透彻，对其中的参数设置有些混乱。
但看了Carl哥的讲解，对照着双指针法把参数写对了。但是对从后往前翻转指针指向的递归写法还是不太理解。
之后还要加强对递归的理解。
代码
双指针法：
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* temp; // 保存cur的下一个节点
ListNode* cur = head;
ListNode* pre = NULL;
while(cur) {
temp = cur->next; // 保存一下 cur的下一个节点，因为接下来要改变cur->next
cur->next = pre; // 翻转操作
// 更新pre 和 cur指针
pre = cur;
cur = temp;
}
return pre;
}
};
递归法（从前往后）：
class Solution {
public:
ListNode* reverse(ListNode* pre,ListNode* cur){
if(cur == NULL) return pre;
ListNode* temp = cur->next;
cur->next = pre;
// 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
// pre = cur;
// cur = temp;
return reverse(cur,temp);
}
ListNode* reverseList(ListNode* head) {
// 和双指针法初始化是一样的逻辑
// ListNode* cur = head;
// ListNode* pre = NULL;
return reverse(NULL, head);
}
};
递归法（从后往前）：
class Solution {
public:
ListNode* reverseList(ListNode* head) {
// 边缘条件判断
if(head == NULL) return NULL;
if (head->next == NULL) return head;
// 递归调用，翻转第二个节点开始往后的链表
ListNode *last = reverseList(head->next);
// 翻转头节点与第二个节点的指向
head->next->next = head;
// 此时的 head 节点为尾节点，next 需要指向 NULL
head->next = NULL;
return last;
}
};
今日收获
1.对链表进行删除操作时，设置虚拟头节点代码格式会工整。
2.完成了对链表的基本操作。
3.反转链表的两种方法：
- 双指针法
- 递归法（理解有待加强）
今日学习时长2h