链表：移除链表元素 设计链表 翻转链表
链表
- 单链表
- 双链表
- 循环链表
在内存中的存储方式：地址不是连续的，通过结点的指针域的指针连接。
适用场景：数据量不固定，增删多，查询少
链表的定义
// 单链表
struct ListNode {
int val; // 节点上存储的元素
ListNode *next; // 指向下一个节点的指针
ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};移除链表元素
题目：Leetcode203
解法一：直接使用原来的链表
- 时间复杂度: O(n)
/**
* 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* removeElements(ListNode* head, int val) {
//直接使用原来的链表来进行删除操作
//缺点：需要单独对头结点进行判断
ListNode* tmp = NULL;
//可能存在从头结点开始连续多个节点需要删除，所以需要使用while
while(head && head->val == val) {
tmp = head;
head = head->next;
delete tmp;
}
ListNode* prev = head;//删除的节点必须能找到前驱结点，借助前驱结点进行删除
//删除非头结点
while(prev && prev->next) {
tmp = prev->next;
if(tmp->val == val) {
prev->next = tmp->next;
delete tmp;
}
else {
prev = prev->next;
}
}
return head;
}
};解法二：使用虚拟头结点
- 时间复杂度: O(n)
/**
* 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* removeElements(ListNode* head, int val) {
//虚拟头结点
//优点：不需要单独对头结点进行判断
ListNode* dummyhead = new ListNode(0);
dummyhead->next = head;
ListNode* prev = dummyhead;
while(prev->next) {
ListNode* tmp = prev->next;
if(tmp->val == val) {
prev->next = tmp->next;
delete tmp;
}
else {
prev = prev->next;
}
}
//头结点可能被删除了，所以要重置为dummyhead的下一个结点
head = dummyhead->next;
delete dummyhead;
return head;
}
};设计链表
题目：Leetcode707
也使用到了虚拟头结点。
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) {
//判断index是否合法，不合法返回-1，index是从0开始的
if(index > (_size - 1) || index < 0) {
return -1;
}
//从头结点开始遍历，每遍历一个结点index-1，当index为0时刚好就是下标为index的结点
//while(index--)这种思路要记住
LinkedNode* tmp = _dummyhead->next;
while(index--) {
tmp = tmp->next;
}
return tmp->val;
}
void addAtHead(int val) {
LinkedNode* newhead = new LinkedNode(val);
//插入新的头结点，实际操作为插入在虚拟头结点和原头结点之间
newhead->next = _dummyhead->next;
_dummyhead->next = newhead;
_size++;
}
void addAtTail(int val) {
LinkedNode* tail = new LinkedNode(val);
LinkedNode* tmp = _dummyhead;
while(tmp->next) {
tmp = tmp->next;
}
tmp->next = tail;
_size++;
}
// 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果index大于链表的长度，则返回空
// 如果index小于0，则在头部插入节点
void addAtIndex(int index, int val) {
//判断index是否合法
if(index > _size) return;
if(index < 0 ) index = 0;
//从虚拟头结点开始遍历index个结点，刚好是第index个结点的前一个结点
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* tmp = _dummyhead;
while(index--) {
tmp = tmp->next;
}
newNode->next = tmp->next;
tmp->next = newNode;
_size++;
}
void deleteAtIndex(int index) {
//判断index是否合法
if(index >= _size || index < 0) return;
LinkedNode* tmp = _dummyhead;
while(index--) {
tmp = tmp->next;
}
LinkedNode* target = tmp->next;
tmp->next = tmp->next->next;
delete target;
//delete命令指示释放了tmp指针原本所指的那部分内存，
//被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
//如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
//如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
target = nullptr;
_size--;
}
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);
*/翻转链表
题目：Leetcode206
思路：改变链表的next指针的指向，直接翻转链表
解法一：利用栈的特性
/**
* 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* reverseList(ListNode* head) {
stack s;
ListNode* tmp = head;
while(tmp) {
s.push(tmp->val);
tmp = tmp->next;
}
tmp = head;
while(!s.empty()) {
tmp->val = s.top();
s.pop();
tmp = tmp->next;
}
return head;
}
}; 解法二：双指针
- 时间复杂度: O(n)
- 为什么要保存临时结点？
- 因为接下来要改变 cur->next 的指向了，将cur->next 指向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* reverseList(ListNode* head) {
ListNode* cur = head;
ListNode* pre = NULL;
while(cur) {
ListNode* tmp = cur->next;//保存下一个结点
cur->next = pre;//改变指针指向
//移动指针，必须先移动pre，否则如果cur先发生改变，pre更新会发生错误
pre = cur;
cur = tmp;
}
return pre;
}
};解法三：递归
和双指针法是一样的逻辑
- 时间复杂度: O(n), 要递归处理链表的每个节点
- 空间复杂度: O(n), 递归调用了 n 层栈空间
/**
* 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* tmp = cur->next;//保存下一个结点
cur->next = pre;//改变指针指向
//移动指针，必须先移动pre，否则如果cur先发生改变，pre更新会发生错误
//递归的写法，其实就是做了这两步
//pre = cur;
//cur = tmp;
return reverse(cur, tmp);
}
ListNode* reverseList(ListNode* head) {
//ListNode* cur = head;
//ListNode* pre = NULL;
return reverse(NULL, head);
}
};总结
虚拟头结点和递归还需要多练习多理解
参考链接
代码随想录：链表理论基础 移除链表元素 设计链表 翻转链表