203.移除链表元素
思路
遍历列表，如果遇到cur->val==val,则将上一节点的索引pre->next = cur->next,并delete cur;
实现遍历的更新条件为：while(cur->next != nullptr) {pre = cur,cur=cur->next}
结果
没做出来，好菜，失去信心。head头节点对应的为val,要删掉的不知道怎么处理
反思
原来有两种方法呀，添加一个虚拟头节点或者删掉后（head = head->next）再确定cur和pre
代码
自己写的更改后的
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* pre,* cur;
while(head != nullptr&&head->val == val){
head = head->next;//重点
}
pre = head;
cur = head;
while(cur != nullptr){
if(cur->val == val){
pre->next = cur->next;
cur = pre->next;
}
else{
pre = cur;
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;
}
};
总结
-
虚拟头节点
-
delete只能delete指针
707.设计链表
思路
就硬写呗
结果
一点都不会
反思
-
没看明白题目
-
要先写链表的初始化函数，然后在类构造函数里面new一个链表，才能进行操作。类的语法都忘了。
-
还要给new出来的链表对应上下标求解
-
创个虚拟头节点
代码
class MyLinkedList {
private:
int _size;
LinkedNode* _dummyHead;//指向该类的指针
public:
// 定义链表节点结构体
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val):val(val), next(nullptr){}
};
// 初始化链表
MyLinkedList() {
_dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
//意思是new的值不用管，_dummyHead->next才是头节点
_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 就会陷入死循环（要先判断再减，不然若index为0）
cur = cur->next;//循环体
}
return cur->val;
}
// 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
void addAtHead(int val) {
LinkedNode* newNode = new LinkedNode(val);
//new一个新值加进去就好了
newNode->next = _dummyHead->next;//新值的next连到原来的头节点，新的头节点就变成newNode了
_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) {//第_size 节点是尾节点的后一个
return;
}
LinkedNode* cur = _dummyHead;
while(index--) {
cur = cur ->next;
}
LinkedNode* tmp = cur->next;//保存指针方便清空空间
cur->next = cur->next->next;//跳过了这个指针
delete tmp;//清空了tmp指向的空间
//delete命令指示释放了tmp指针原本所指的那部分内存，
//被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
//已经new了一个新的tmp，如果不再加上一句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;
}
};
总结
定义链表结构体
struct ListNode {
int val; // 表示节点存储的整数值
ListNode *next; // 指向下一个节点的指针
// 默认构造函数，初始化 val 为 0，next 指针为 nullptr
ListNode() : val(0), next(nullptr) {}
// 单参数构造函数，初始化 val 为 x，next 指针为 nullptr
ListNode(int x) : val(x), next(nullptr) {}
// 双参数构造函数，初始化 val 为 x，next 指针为给定的 next 指针
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
定义虚链表头
LinkedNode L_dummyHead = new LinkedNode(0);
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr) {
cur = cur ->next;
}
206.反转链表
思路
反转就是从最后一个开始往前读取。需要把next的地址更新。例如5->next = 3->next,4->next = 2->next,······2->next = _dummyhead->next。
结果
错误，为啥前面自己用了双指针，现在就想不到呢
反思
-
没有使用双指针的思路
代码
双指针
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* cur = head;
ListNode* pre = nullptr;
ListNode* temp;
while(cur){
temp = cur->next;
cur->next = pre;
pre = cur;
cur = temp;
}
return pre;
}
};
递归法
递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。
关键是初始化的地方，可能有的同学会不理解， 可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。
具体可以看代码（已经详细注释），双指针法写出来之后，理解如下递归写法就不难了，代码逻辑都是一样的。
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) {
return recur(head, nullptr); // 调用递归并返回
}
private:
ListNode* recur(ListNode* cur, ListNode* pre) {
if (cur == nullptr) return pre; // 终止条件
ListNode* res = recur(cur->next, cur); // 递归后继节点
cur->next = pre; // 回溯修改节点引用指向
return res; // 返回反转链表的头节点
}
};
-
时间复杂度: O(n), 要递归处理链表的每个节点
-
空间复杂度: O(n), 递归调用了 n 层栈空间
我们可以发现，上面的递归写法和双指针法实质上都是从前往后翻转指针指向，其实还有另外一种与双指针法不同思路的递归写法：从后往前翻转指针指向。
递归回溯
具体代码如下（带详细注释）：
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;
}
};
-
时间复杂度: O(n)
-
空间复杂度: O(n)
总结
递归法
理解起来和循环很像，不过就是更新变量，然后给出一个return结束循环的条件。
双指针法
相比起来简单
递归回溯
先入后出，后来居上
递归回溯是指在递归过程中，当达到递归终止条件后，递归函数开始返回，此时开始依次执行之前递归调用中未执行的部分。换句话说，递归回溯就是在递归调用的过程中，当递归函数返回时，程序执行顺序回溯到之前的某一点，继续执行未完成的代码。
扫一扫
236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
