今天照例边做边写。
目录
链表理论基础
关于这里的部分我上学期的数据结构课程已经有了较为全面的学习,就不多写了。
203.移除链表元素
建议: 本题最关键是要理解 虚拟头结点的使用技巧,这个对链表题目很重要。题目链接/文章讲解/视频讲解:代码随想录
题目:
给你一个链表的头节点 head
和一个整数 val
,请你删除链表中所有满足 Node.val == val
的节点,并返回 新的头节点 。
思路:
我此前已经学习过链表,所以这道题相对来说比较简单,代码如下:
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
while (head != nullptr && head->val == val) {
ListNode* tmp = head;
head = head->next;
delete tmp;
}
ListNode* p = head;
while (p != nullptr && p->next!= nullptr) {
if (p->next->val == val) {
ListNode* tmp = p->next;
p->next = p->next->next;
delete tmp;
}
else p = p->next;
}
return head;
}
};
主要的思路是设一个新的结点p进行遍历原链表,移除其中的目标结点,使原链表本身发生变化。重要的是,处理头结点与其他结点的方法不同,尤其要注意头结点及它后面多个结点为目标节点的情况(用while!)。
代码随想录有另一种解法,以下是范例:
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.设计链表
建议: 这是一道考察 链表综合操作的题目,不算容易,可以练一练 使用虚拟头结点题目链接/文章讲解/视频讲解:代码随想录
题目:
你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:val
和 next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。
如果是双向链表,则还需要属性 prev
以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList
类:
MyLinkedList()
初始化MyLinkedList
对象。int get(int index)
获取链表中下标为index
的节点的值。如果下标无效,则返回-1
。void addAtHead(int val)
将一个值为val
的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。void addAtTail(int val)
将一个值为val
的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)
将一个值为val
的节点插入到链表中下标为index
的节点之前。如果index
等于链表的长度,那么该节点会被追加到链表的末尾。如果index
比长度更大,该节点将 不会插入 到链表中。void deleteAtIndex(int index)
如果下标有效,则删除链表中下标为index
的节点。
思路:
知识有点记不太清,花了很长时间,代码如下:
class MyLinkedList {
public:
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val):val(val), next(nullptr){}
};
MyLinkedList() {
Head = new LinkedNode(0);
size = 0;
}
int get(int index) {
if (index > (size - 1) || index < 0) {
return -1;
}
LinkedNode* p = Head->next;
while(index--){
p = p->next;
}
return p->val;
}
void addAtHead(int val) {
LinkedNode* p = new LinkedNode(val);
p->next = Head->next;
Head->next = p;
size++;
}
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode*p = Head;
while(p->next != nullptr){
p = p->next;
}
p->next = newNode;
size++;
}
void addAtIndex(int index, int val) {
if(index > size) return;
if(index < 0) index = 0;
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* p =Head;
while(index--) {
p = p->next;
}
newNode->next = p->next;
p->next = newNode;
size++;
}
void deleteAtIndex(int index) {
if (index >= size || index < 0) {
return;
}
LinkedNode* p = Head;
while(index--) {
p = p ->next;
}
LinkedNode* tmp = p->next;
p->next = p->next->next;
delete tmp;
size--;
}
private:
int size;
LinkedNode* Head;
};
基本满足题目要求。
206.反转链表
建议先看我的视频讲解,视频讲解中对 反转链表需要注意的点讲的很清晰了,看完之后大家的疑惑基本都解决了。题目链接/文章讲解/视频讲解:代码随想录
题目:
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
提示:
- 链表中节点的数目范围是
[0, 5000]
-5000 <= Node.val <= 5000
进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?
思路:
做这道题的时候,我的思路比较简单,若这个链表为空,那么返回一个空链表,若不为空,先用一个新结点p遍历原来的链表,存储每一个结点的值到一个数组,然后从后往前遍历这个数组,来创建一个新链表。因此我写下了以下代码:
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(head==nullptr) return nullptr;
ListNode* p = new ListNode(0);
p->next = head;
ListNode* c=p;
int* a = new int[100];
int i = 0;
while(p->next!=nullptr){
a[i]=p->next->val;
i++;
}
ListNode* nhead = new ListNode(0);
p->next = nhead;
for(int x = i;x--;x > -1){
p->next->val=a[x];
p=p->next;
}
return nhead;
}
};
不幸的是,编译因未知原因报错,不得不另寻他路。
代码随想录提供了两种方法。
1.双指针法:
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;
}
};
简单来说就是逐个改变结点指向方向。
2.递归法:
与双指针差不多,待理解。
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);
}
};