算法训练Day3：移除链表元素，设计链表，反转链表
文章目录
- 移除链表元素
-
- 自己写的错误代码（恶心）
- 正确答案(原链表操作)
- 设置一个虚拟头结点在进行移除节点操作：
- 设计链表
-
- 采用虚拟结点解法
- 反转链表
-
- 分析总结
移除链表元素
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Easy (54.74%) | 1195 | 0 | - | - | 0 |
递归 | 链表
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
提示：
- 列表中的节点数目在范围
[0, 104]内 1 <= Node.val <= 500 <= val <= 50
Discussion | Solution
自己写的错误代码（恶心）
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* p ,*q;
p = head,q = head->next;
while(q){
if(p->val==val&& p == head){
head = q;
}else if(p->val==val) {
p = q->next;
}
p = p->next;
q = q->next;
}
return head;
}
};
正确答案(原链表操作)
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
//删除头结点
while(head != NULL && head->val == val) {
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;
}
};
设计链表
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Medium (34.70%) | 776 | 0 | - | - | 0 |
你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：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的节点。
示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]
解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3
提示：
0 <= index, val <= 1000- 请不要使用内置的 LinkedList 库。
- 调用
get、addAtHead、addAtTail、addAtIndex和deleteAtIndex的次数不超过2000。
Discussion | Solution
采用虚拟结点解法
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) 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++;
}
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 printfLinkedNode() {
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr) {
cout << cur->next->val << " ";
cur = cur->next->next;
}
cout << endl;
}
private:
int _size;
LinkedNode* _dummyHead;
};
反转链表
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Easy (73.48%) | 3034 | 0 | - | - | 0 |
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
- 链表中节点的数目范围是
[0, 5000] -5000 <= Node.val <= 5000
**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
Discussion | Solution
/*
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* cur = head;
ListNode* tmp ;
while(cur) {
tmp = cur->next;
cur->next = pre;
pre = cur;
cur = tmp;
}
return pre;
}
};
分析总结
第一遍刷题总是有点慢，不过慢慢来吧，建议大家10分钟没思路，立马看题解。
ListNode* reverseList(ListNode* head) {
ListNode* pre = nullptr;
ListNode* cur = head;
ListNode* tmp ;
while(cur) {
tmp = cur->next;
cur->next = pre;
pre = cur;
cur = tmp;
}
return pre;
}
};
## 分析总结
第一遍刷题总是有点慢，不过慢慢来吧，建议大家10分钟没思路，立马看题解。