1、链表的定义
struct ListNode{
int val; //节点上存储的元素
ListNode* next;//指向下一个节点的指针
ListNode(int x) : val(x), next(nullptr){}//节点的构造函数
//注意:不写这个构造函数,C++也会默认生成一个构造函数,但是默认生成的构造函数,不会初始化任何成员变量。
// 如果不定义而是使用默认构造函数,那么在初始化的时候就不能直接给变量赋值
};
// C++中,删除节点,最好手动释放这个节点和这块内存。
2、用虚拟头节点会方便的多
删除节点
class Solution{
public:
ListNode * removeElements(ListNdoe* head, int val){
// 删除头节点
while(head != NULL && head -> val == val){
ListNode* tmp = head;
head = head -> next;
delete tmp;
}
//删除非头节点(确保有两个以上节点:头节点+非头节点)
ListNode* cur = head;
// 检查当前节点cur不为NULL,并且下一个节点cur->next也不为null。如果两个条件成立,则意味着链表中至少还有两个节点,循环可以继续迭代。
while(cur != NULL && cur -> next != NULL){ //头节点不为NULL,且下一个节点也不为NULL
if(cur->next->val == val){ // 若下一个节点的值为要删除的val,则删除
ListNdoe* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
}else{
cur = cur->next;
}
}
return head;
}
};
给链表添加一个虚拟头节点并将其设为新的头节点
作用:从链表中删除所有值等于val的节点,并且返回删除后的链表头节点。
class Solution {
public:
ListNode* removeElement(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;//使用C++时需要手动释放内存(动态分配内存:在合适的时候,手动释放内存,以避免内存泄漏)
}else{
cur = cur -> next;
}
}
head = dummyHead->next;
delete dummyHead; //使用C++时需要手动清理内存
return head;
}
}
3、链表常见的六个操作
class MyLinkedList{
public:
//定义链表结点的结构体
struct LinkedNode{
int val;
ListNode* next;
LinkedNode(int val):val(val),next(nullptr){}//构造函数:接收一个整型参数val,并用该参数初始化val成员变量,将next成员变量初始化一个空指针。
};
//初始化链表
MyLinkedList(){
//这里定义的头节点是一个虚拟头节点,而不是真正的链表头节点
_dummyHead = new ListNode(0);
_size = 0;
}
//获取第index个节点的数值,如果index是非法数值则直接返回-1
//注意index是从0开始的,第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 addHead(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++;
}
//在第index个节点之前插入一个新节点
//如果index为0,那么新插入的节点为链表新的头节点
//如果index等于链表长度,则说明新插入的节点为链表的尾节点
//如果index大于链表的长度,则返回空
void addAtIndex(int index, int val){
if(index > _size){
return;
}
LinkedNode* newNode = new LinkedNode(val);
LinkNode* cur = _dummyHead;
while(index--){
cur = cur->next;
}
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
//删除第index个节点,如果index大于或等于链表的长度,则直接返回
// 注意index是从0开始的
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 printLinkedList(){
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cout << cur->next->val << " ";
cur = cur -> next;
}
cout<<endl;
}
private:
int _size;
LinkedNode* _dummyHead;
};
4、反转列表
题目描述:反转一个单链表。要求是不能申请额外的内存空间
思路: 如果定义一个新的链表元素的反转,则是对内存空间的浪费,其实只需要改变链表的next指针的指向,直接将链表反转即可,而不用重新定义一个新的链表
方法一:双指针法
class Slution{
public:
ListNode* reverseList(ListNode* head){
ListNode* temp;
ListNode* cur = head;
ListNode* pre = nullptr;
//当cur为空的时候循环结束,不断的将cur指向pre的过程
while(cur){
//保存cur的下一个节点,因为接下来要改变cur->next的指向了
temp = cur->next;;
cur -> next = pre;
pre = cur;
cur = temp;
}
return pre;
}
};
方法二:递归法
class Slution{
public:
ListNode* reverse(ListNode* pre, ListNdoe* cur) //反转链表
{
// 每次递归将当前节点的next指针指向前一个节点,然后递归到下一个节点。
// 当前节点为nullptr的时候,递归结束,返回前一个节点pre
if(cur == nullptr) return pre;
ListNode* temp = cur -> next;
cur -> next = pre;
return reverse(cur , temp);
}
ListNode* reverseList(ListNode* head){
return reverse(nullptr, head);
}
};
5、删除链表的倒数第n个节点
题目描述:删除链表的倒数第n个节点(n从1开始)。
思路:如果要删除倒数第n个节点,则让fast移动n步,然后让fast和slow同时移动,直到fast指向链表末尾,删除slow所指向的结点就可以了。
该实现使用了双指针技巧来遍历链表。创建一个虚拟头节点,将其next指针设置为原始头节点。然后使用两个指针,slow和fast,遍历链表。
快指针在慢指针的前面移动n步。然后,两个指针都向前移动,直到快指针到达链表的末尾。
此时,慢指针指向倒数第n个节点的前一个节点。实现通过将慢指针的下一个指针更新为指向倒数第n个节点后面的节点来删除倒数第n个节点。
为了删除倒数第n个节点,使用快慢指针法,让指针fast索引减去指针slow索引的差值为n+1。为什么是n+1,因为删除倒数第n个节点,需要找到其前置节点,改变前置节点的指针域即可删除节点
class Slution{
public:
ListNode* removeNthFromEnd(ListNode* head, int n){
ListNode* dummyHead = new ListNode(0);//定义虚拟头节点
dummyHead->next = head;
ListNode* slow = dummyHead;
ListNode* fast = dummyHead;
while(n-- && fast != nullptr){
fast = fast -> next;
}
//fast在提前移动一步,因为需要让slow指向删除节点的上一个节点
fast = fast ->next;
while(fast!=nullptr){
fast = fast -> next;
slow = slow -> next;
}
slow ->next= slow ->next->next;
return dummyHead->next;
}
};
6、环形链表
题目描述: 判断链表是否有环,如果有环,则找到入环的第一个节点,如果无环,则返回NULL。
思路:1、判断链表是否循环;2、如果有环,如何找到这个环的入口
算法步骤如下:
定义两个指针 fast 和 slow,初始值都为头结点 head。
使用 while 循环,判断 fast 指针和 fast 的下一个节点是否都不为 NULL,如果有一个为 NULL,说明链表没有环,退出循环。
在循环中,每次慢指针 slow 只向前移动一步,快指针 fast 则向前移动两步。
当快指针追上慢指针时,说明链表有环。此时从头结点 head 和相遇点同时出发,同时移动指针,直到两个指针相遇。相遇点即为环的入口节点。
如果没有找到环,则返回 NULL。
这个算法的时间复杂度为 O(n),其中 n 是链表的长度,空间复杂度为 O(1),因为只使用了常数级别的额外空间。
/* 检测链表是否有环,如果有环,找到如环的第一个节点;如果没有环,则返回NULL。*/
class Slution{
public:
ListNode* detectCycle(ListNode* head)
{
//使用快慢指针,判断是否有环
ListNode* fast = head;
ListNode* slow = head;
while(fast != nullptr && fast->next != nullptr){
slow = slow->next;
fast = fast->next->next;
if(slow == fast){
//判断存在环,找环入口
ListNode* index1 = fast;
ListNode* index2 = head;
while(index1 != index2){
index1 = index1->next;
index2 = index2->next;
}
return index2;
}
}
return nullptr;
}
};