算法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层。