本文介绍了链表相关的LeetCode题目，包括如何删除链表中指定值的节点，设计链表的get、add、delete等操作，以及反转链表、两两交换节点、删除倒数第N个节点、找到链表相交节点和检测环形链表的方法。这些操作普遍利用了哑节点和双指针技巧，简化了问题处理。
-
1 移除链表元素
LeetCode：移除链表元素
没什么好说的，使用虚假头结点dummy_node避免特殊情况的出现，将前节点与后节点相连即可。
题目：删除链表中等于给定值 val 的所有节点。
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
//哑节点
if(head==nullptr)return head;
ListNode* dummpy_node=new ListNode(head->val,head);
ListNode* cur_node=head;
ListNode* pre_node=dummpy_node;
while(cur_node!=nullptr)
{
if(cur_node->val==val)
{
pre_node->next=cur_node->next;
cur_node=cur_node->next;
}
else
{
cur_node=cur_node->next;
pre_node=pre_node->next;
}
}
return dummpy_node->next;
}
};
-
2 设计链表
LeetCode：设计链表
同样是哑结点的使用，与此同时，必须对index进行异常处理，包括<0与>length的情况
题目：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
1 get(index)：获取链表中第index个节点的值。如果索引无效，则返回-1。
2 addAtHead(val)：在链表的第一个元素之前添加一个值为val的节点。插入后，新节点将成为链表的第一个节点。
3 addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
4 addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
5 deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
class MyLinkedList {
public:
//节点
class MyNode
{
public:
int val;
MyNode* next;
MyNode(int val)
{
this->val=val;
this->next=nullptr;
}
};
public:
MyNode* dummpy_head;
MyLinkedList() {
dummpy_head=new MyNode(0);
}
int get(int index) {
if(index<0)return -1;
MyNode* cur_node=dummpy_head;
for(int i=0;i<=index;i++)
{
cur_node=cur_node->next;
if(cur_node==nullptr)return -1;
}
return cur_node->val;
}
void addAtHead(int val) {
MyNode* new_head=new MyNode(val);
new_head->next=dummpy_head->next;
dummpy_head->next=new_head;
}
void addAtTail(int val) {
MyNode* cur_node=dummpy_head;
while(cur_node->next!=nullptr)
{
cur_node=cur_node->next;
}
MyNode* new_tail=new MyNode(val);
new_tail->next=nullptr;
cur_node->next=new_tail;
}
void addAtIndex(int index, int val) {
if(index<0)return;
if(index==0)addAtHead(val);
else
{
MyNode* cur_node=dummpy_head;
for(int i=0;i<index;i++)
{
cur_node=cur_node->next;
if(cur_node==nullptr)return;
}
MyNode* new_node=new MyNode(val);
new_node->next=cur_node->next;
cur_node->next=new_node;
}
}
void deleteAtIndex(int index) {
if(index<0)return;
MyNode* cur_node=dummpy_head;
for(int i=0;i<index;i++)
{
cur_node=cur_node->next;
if(cur_node==nullptr)return;
}
MyNode* tmp=cur_node->next;
if(tmp==nullptr)return;
cur_node->next=tmp->next;
}
};
-
3 反转链表
LeetCode：反转链表
采用双指针进行操作，注意pre、cur、next三个节点的连接顺序，这里采用了cur->pre,pre->next的顺序进行操作。
题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
另外对尾结点（原来的头结点）进行特殊处理。
class Solution {
public:
ListNode* reverseList(ListNode* head) {
//排除无需翻转的情况
if(head==nullptr || head->next==nullptr)return head;
//双指针
ListNode* pre_node=head;
ListNode* cur_node=head->next;
ListNode* tmp;
while(cur_node!=nullptr)
{
tmp=cur_node->next;
cur_node->next=pre_node;
pre_node=cur_node;
cur_node=tmp;
}
//head变tail
head->next=nullptr;
//返回原来的tail
return pre_node;
}
};
-
4 两两交换链表中的节点
LeetCode：两两交换链表中的节点
显然是一个多指针题目，由于节点位置会发生变化，采用了虚假头结点来简化操作过程，并且用以输出新的头结点。
题目：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（只能进行节点交换）。
总共需要3个指针，用以存储pre、swap1和swap2三个节点，注意交换顺序，并且更新pre节点。
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
//排除空与单元素链表
if(head==nullptr || head->next==nullptr)return head;
//虚假节点
ListNode* dummpy_node=new ListNode(0,head);
//三指针
ListNode* pre_node=dummpy_node;
ListNode* swap_node1;
ListNode* swap_node2;
while(pre_node->next!=nullptr && pre_node->next->next!=nullptr)
{
//确立交换节点
swap_node1=pre_node->next;
swap_node2=swap_node1->next;
//交换
swap_node1->next=swap_node2->next;
swap_node2->next=swap_node1;
pre_node->next=swap_node2;
//pre_node更新
pre_node=swap_node1;
}
//返回头节点
return dummpy_node->next;
}
};
-
5 删除链表的倒数第N个节点
LeetCode：删除链表的倒数第N个节点
利用快慢两个指针进行操作即可。
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
或者遍历两次，第一次记录下链表的长度。
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
//不存在空链表，可忽略一些特殊情况判断
//建立虚假节点
ListNode* dummpy_node=new ListNode(0,head);
//双指针
ListNode* slow=dummpy_node;
ListNode* fast=dummpy_node;
//fast快n步
for(int i=0;i<n;++i)
fast=fast->next;
//slow定位到删除节点的前一个节点
while(fast->next!=nullptr)
{
fast=fast->next;
slow=slow->next;
}
//删除节点
slow->next=slow->next->next;
return dummpy_node->next;
}
};
-
6 链表相交
LeetCode：链表相交
只要求出两个链表的长度，利用两者的长度差进行A、B双指针的同步就可以简单地获得最终的交点。
题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if(headA==nullptr || headB==nullptr)return NULL;
int lengthA=0;
int lengthB=0;
ListNode* cur_A=headA;
ListNode* cur_B=headB;
while(cur_A!=nullptr)
{
cur_A=cur_A->next;
++lengthA;
}
cur_A=headA;
while(cur_B!=nullptr)
{
cur_B=cur_B->next;
++lengthB;
}
cur_B=headB;
if(lengthA>lengthB)
{
for(int i=0;i<lengthA-lengthB;++i)
cur_A=cur_A->next;
}
else
{
for(int i=0;i<lengthB-lengthA;++i)
cur_B=cur_B->next;
}
while(cur_A!=nullptr&&cur_B!=nullptr&&cur_A!=cur_B)
{
cur_A=cur_A->next;
cur_B=cur_B->next;
}
if(cur_A==nullptr||cur_B==nullptr)return NULL;
else return cur_A;
}
};
-
7 环形链表II
LeetCode：环形链表II
利用速度分别为1和2的快慢双指针进行求解。
题目：
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
设入环前的距离为x，环内相遇地点距离环起点距离为m，环长度为n。
利用两者速度之间的差距，可以得到方程：2(x+m)=x+m+kn。
即x=m+kn=(k-1)n+(n-m)，其中n-m为slow指针第一圈中距离起点的剩余路程
这意味着此刻从起点出发的指针，必然会与slow指针在环处相遇
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
//排除特殊情况
if(head==NULL || head->next==NULL)return NULL;
ListNode* slow=head;
ListNode* fast=head;
while(fast!=nullptr)
{
//非环
if(fast->next==nullptr || fast->next->next==nullptr)return NULL;
//相对速度为1
slow=slow->next;
fast=fast->next->next;
//如果相遇，跳出循环，这说明确实有环
if(slow==fast)break;
}
//到这一步已经说明肯定有环了
int pos=0;
//重复利用fast指针，这时从起点以1的速度移动
fast=head;
while(1)
{
if(fast==slow)return slow;
else
{
fast=fast->next;
slow=slow->next;
}
}
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
