算法Day3
一、链表基础知识
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链表的入口节点称为链表的头结点也就是head。
链表分类
单链表
单链表示意图: 
单链表中的指针域只能指向节点的下一个节点。
双链表
双链表示意图: 
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
循环列表
循环列表示意图: 
链表首尾相连
循环链表可以用来解决约瑟夫环问题。
链表的存储方式
链表是通过指针域的指针链接在内存中各个节点。
所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
如图所示: 
这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。
链表的定义
定义链表节点方式
// 单链表
/**
* 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) {}
* };
*/
struct ListNode {
int val; // 节点上存储的元素
ListNode *next; // 指向下一个节点的指针
ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};
二、移除链表元素
题目链接
Leetcode203
题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
题目思路
删除节点
删除D节点: 
只要将C节点的next指针 指向E节点就可以了。
但D节点依然存留在内存里，只不过是没有在这个链表里而已。
需要再手动释放这个D节点，释放这块内存。
判断节点类型
删除节点时需要判断当前节点是不是头节点，移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。
所以头结点如何移除，其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。
虚拟头节点
那么能不能以一种统一的逻辑来移除链表的节点呢。
其实可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。
代码
判断节点类型
/**
* 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) {
//首先判断是不是头节点
//删除头节点
//节点不能为空
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;
}
};
时间复杂度：O(n)
空间复杂度：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;//将虚拟头结点指向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;
}
};
时间复杂度：O(n)
空间复杂度：O(n）
三、设计链表
题目链接
Leetcode707
题目：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
题目思路
使用虚拟头节点对链表进行操作。
代码
虚拟头节点
class MyLinkedList {
public:
// 定义链表节点结构体
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val):val(val), next(nullptr){}
};
//初始化链表
MyLinkedList() {
_dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
_size = 0;
}
//链表从0开始
//获取链表中第 index 个节点的值。如果索引无效，则返回-1。
int get(int index) {
while(index < 0 || index > (_size-1)){
return -1;
}
LinkedNode *cur = _dummyHead->next;
while(index){
cur = cur->next;
index--;
}
return cur->val;
}
//在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
void addAtHead(int val) {
LinkedNode* newNode = new LinkedNode(val);
newNode->next = _dummyHead->next;//先将新头节点和之前头节点进行链接
_dummyHead->next = newNode; //将虚拟头节点与新头节点进行链接
_size++;
}
//将值为 val 的节点追加到链表的最后一个元素。
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(cur->next != NULL){
cur = cur->next;
}
cur->next = newNode;
_size++;
}
//在链表中的第 index 个节点之前添加值为 val 的节点。如果 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 个节点。
void deleteAtIndex(int index) {
if(index <0 || index > (_size-1)) return;
LinkedNode* cur = _dummyHead;
while(index--) {
cur = cur->next;
}
LinkedNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
_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);
*/
时间复杂度：初始化消耗 O(1)，get消耗 O(index)，addAtHead消耗 O(1)，addAtTail消耗O(n)，其中n为链表当前长度，即addAtHead，addAtTail和 addAtIndex已调用次数之和，addAtIndex消耗 O(index)。
空间复杂度：所有函数的单次调用空间复杂度均为 O(1)，总体空间复杂度为 O(n)，其中n为 addAtHead，addAtTail 和 addAtIndex调用次数之和。
四、反转链表
题目链接
Leetcode206
题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例: 
题目思路
使用双指针法
定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。
首先要把 cur->next 节点用tmp指针保存一下。
接下来要改变 cur->next 的指向，将cur->next 指向pre ，此时已经反转了第一个节点了。
接下来，继续更新移动pre和cur指针。
最后，当cur 指针已经指向null，循环结束，链表也反转完毕。
此时return pre指针就可以了，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* temp;
ListNode* cur = head;
ListNode* pre = NULL;
while(cur){
temp = cur->next; //保存cur后一节点
cur->next = pre; //将cur指向前一节点
pre = cur; //将pre向后更新
cur = temp; //将cur向后更新
}
return pre;
}
};
时间复杂度：O(n)，其中 n是链表的长度。需要遍历链表一次
空间复杂度：O(1）
递归法
/**
* 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;
return reverse(NULL,head);
}
//递归函数
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);
}
};
时间复杂度：O(n)，其中 n是链表的长度。需要对链表的每个节点进行反转操作
空间复杂度：O(n），其中 n是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n层。
3923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
