8. 移除链表元素
首先作者想要声明一点,关于链表如何定义的内容,还没学明白,文中先不涉及(后续会补上),只是涉及具体操作
作者也是第一遍学,如有错误,还请不吝赐教
C++:
移除链表元素的方法,有两种:
- 直接使用原来的链表进行删除操作
- 设置一个虚拟头结点再进行删除操作
下面挨着来:
- 直接使用原来的链表进行删除
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;
}
}
ListNode* removeElements(ListNode* head, int val)
这是函数的声明部分,指定了函数的返回类型是一个listNode
类型的指针,传入的参数包括一个指向ListNode
类型的指针head
,和一个整型参数val
,表示要删除的结点的值。使用指针的方式,把链表头结点的地址传入到函数中,方便对链表直接进行修改,传出的是处理之后,链表头结点的地址- 头结点为空是什么含义还没有很深刻的理解清楚。head != NULL
- 在找到想要删除的结点之后,为什么需要创建一个新的指针tmp去承接这个结点,而不是直接删去呢?
- 直接让
head = head->next;
或cur->next = cur->next->next;
是没有问题的,但这样做会导致无法释放掉被删除结点所占用的内存空间,从而造成内存泄漏。因此,为了保持链表的连接关系并正确释放内存,需要通过创建临时指针tmp
,将需要删除的结点地址保存起来,并在删除操作后使用delete
操作符释放内存空间。- 解释,为什么在删除头结点的地方,使用while,而不是if,这是为了防止在链表的头部,出现多个待删除的数值val,如果我们使用的是if,当头结点出现多个val的时候,就只能删去一个,而不能完美的符合条件
- 设置一个虚拟头结点再进行删除操作
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;
}
};
结合上面的,这个代码就比较好理解了,使用关键字
new
创建一个虚拟的头结点,然后让头结点指向现实的头结点,之后,再创建一个用于循环的ListNode类型指针,去进行遍历,如果找到要删去的val,那就创建一个临时指针,然后承接需要删去的结点的地址,移动上一个结点的指向,再把这个tmp清空。
9. 设计链表
C++:
本题主要是涉及几个对链表的操作,我们就使用设置一个虚拟头结点再进行操作这种方法来
class MyLinkedList {
public:
// 定义链表节点结构体
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val):val(val), next(nullptr){}
};
// 初始化链表
MyLinkedList() {
_dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点,而不是真正的链表头结点
_size = 0;
}
// 获取到第index个节点数值,如果index是非法数值直接返回-1, 注意index是从0开始的,第0个节点就是头结点
int get(int index) {
if (index > (_size - 1) || index < 0) {
return -1;
} // 提升代码的健壮性,你给的是不和要求的数值也可以不报错
LinkedNode* cur = _dummyHead->next;
while(index--){ // 如果--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++;
}
// 在第index个节点之前插入一个新节点,例如index为0,那么新插入的节点为链表的新头节点。
// 如果index 等于链表的长度,则说明是新插入的节点为链表的尾结点
// 如果index大于链表的长度,则返回空
// 如果index小于0,则在头部插入节点
void addAtIndex(int index, int val) {
if(index > _size) return;
if(index < 0) index = 0;
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(index--) {
cur = cur->next;
}
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
// 删除第index个节点,如果index 大于等于链表的长度,直接return,注意index是从0开始的
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;
//delete命令指示释放了tmp指针原本所指的那部分内存,
//被delete后的指针tmp的值(地址)并非就是NULL,而是随机值。也就是被delete后,
//如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
//如果之后的程序不小心使用了tmp,会指向难以预想的内存空间
tmp=nullptr;
_size--;
}
// 打印链表
void printLinkedList() {
LinkedNode* cur = _dummyHead;
while (cur->next != nullptr) {
cout << cur->next->val << " ";
cur = cur->next;
}
cout << endl;
}
private:
int _size;
LinkedNode* _dummyHead;
};
- 在定义链表结点结构体的地方,有必要强调一点
LinkedNode(int val):val(val), next(nullptr){}
是定义在结构体中的构造函数,算是有参构造函数,传入int类型的参数val,然后将该参数传给val,默认指针next指向空nullptr,表示初始时该结点没有下一个结点,即是链表的最后一个结点。MyLinkedList
函数是该类的构造函数,在声明MyLinkedList
类的时候,就会创建一个虚拟的头结点,而这个头结点不是真正的链表头结点
自己在打的时候,把
struct LinkedNode{
int val;
LinkedNode* next;
LinkedNode(int val):val(val), next(nullptr){}
};
这个类内的结构体末尾的 ;
给忘记了,然后就出现了报错:
Line 3: Char 12: error: 'MyLinkedList::LinkedNode' cannot be defined in the result type of a function
3 | struct LinkedNode{
| ^
所以打的时候,还是需要小心的,添上分号之后就好了。
或者将这个类内的结构,转移到类的外部,也是可以的。
10. 反转链表
C++:
第一种就是双指针法,比较简单
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;
}
};
第二种是递归法:
/**
* 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* 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);
}
};
这个,目前还没转明白,代码随想录上说挺简单的,还得再想想,想明白了回来记录:
==》
自我理解,写递归的代码,大概思考两步:1.考虑结束条件;2.写出每步执行的内容;
这里的递归代码其实是照着双指针的搬过来写的,没有很大改动。主函数调用反转函数,因为反转函数最后输出的内容就是反转后的链表的头结点指针,所以直接已return的方式输出这个头结点指针即可。在递归函数中,首先写结束的条件,当current指针指向NULL表示已经结束,返回pre指针;然后写每步需要执行的内容,每步需要使用temp接收current结点的指针指向,接收之后修改current结点的指针指向,最后再次调用递归函数,完成pre = cur; cur = temp这两步,也就是reverse(cur, temp)。
需要注意的一个大问题是,传参的顺序是谁传给谁!
第三种方法:
上面的递归写法和双指针法实质上都是从前往后翻转指针指向,其实还有另外一种与双指针法不同思路的递归写法:从后往前翻转指针指向。
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;
}
};