LeetCode和牛客网经典链表题目合集
目录
LeetCode第203题：移除链表元素
LeetCode第206题：反转链表
LeetCode第876题：链表的中点节点
牛客网：链表中倒数最后k个节点
LeetCode第21题：合并两个有序链表
牛客网：分割链表
牛客网：链表的回文结构
LeetCode第160题：相交链表
LeetCode第141题：环形链表
LeetCode第142题：环形链表II
LeetCode第138题：复制带随机指针的链表
本期博客我将对一些经典的链表题进行总结详解
LeetCode第203题：移除链表元素
题目链接：
203. 移除链表元素
对于此题我的想法是直接将链表中等于val值的节点从链表中移除就行：
struct ListNode* removeElements(struct ListNode* head, int val)
{
struct ListNode* temp1 = head;
struct ListNode* temp2 = head;
int i = 0;
if (temp1 == NULL)
{
return head;
}
while (temp1)
{
if (i == 0)
{
if (head->val == val)
{
head = head->next;
temp1 = head;
temp2 = head;
}
else
i++;
}
else
{
if (temp1->val == val)
temp2->next = temp1->next;
else
temp2 = temp1;
temp1 = temp1->next;
}
}
return head;
}成功通过：
LeetCode第206题：反转链表
题目链接：
206. 反转链表
本题我先想到了使用递归的方法，先用函数层层递归找到链表最后一个节点，再将每一层所传的节点用尾插法存入一个全局结构体指针变量temp中，最后返回temp这个指针就可以了：
void SListPushBack(struct ListNode** pplist, struct ListNode* node)//这里由于我们要改变链表指针的指向，需要使用二级指针来控制
{
struct ListNode* newplist = node;//创建一个新节点为插入链表做准备
newplist->next=NULL;
if (*pplist == NULL)//如果传入的是个空链表就直接插入一个新节点
{
*pplist = newplist;
return;
}
//传入的不是空链表就找到链表尾部
struct ListNode* tail = *pplist;
while (tail->next)
{
tail = tail->next;
}
tail->next = newplist;//在链表尾部插入数据
}
struct ListNode* temp = NULL;
void returnNode(struct ListNode* node)
{
if (node == NULL)
return;
returnNode(node->next);
SListPushBack(&temp, node);
}
struct ListNode* reverseList(struct ListNode* head) {
temp = NULL;
returnNode(head);
return temp;
}
使用递归的方法时间复杂度为O(n)，空间复杂度为O(n)运行起来不是很理想：
接下来使用迭代法来解决它：
在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
struct ListNode* reverseList(struct ListNode* head) {
if (head == NULL || head->next == NULL)
return head;
struct ListNode* temp = NULL, * new = NULL, * List = head->next;
int i = 0;
while (List->next)
{
if (i == 0)
{
new = head;
new->next = NULL;
i++;
}
else {
temp = List;
List = List->next;//在temp被修改之前要提前找到链表的下一个节点，否则在下一步temp->被修改时List也会被修改从而丢失链表的下一个节点
temp->next = new;
new = temp;
}
}
return new;
}
此方法只需要遍历一次链表时间复杂度为O(n)，空间复杂度为O(1)的效果：
LeetCode第876题：链表的中点节点
题目链接：
876. 链表的中间结点
此题我们使用快慢指针的方法可以快速的解决掉该题：
设置两个遍历链表的指针fast和slow指针，fast指针每次遍历链表的两个节点，slow每次遍历链表的一个节点。当fast指针遍历完链表之后slow指针才遍历完整个链表的一半。此时返回slow指针即为链表的中间节点。
struct ListNode* middleNode(struct ListNode* head){
struct ListNode*fast=head,*slow=head;
while(fast!=NULL&&fast->next!=NULL)
{
fast=fast->next->next;
slow=slow->next;
}
return slow;
}此方法只要遍历一次链表时间复杂度为O(n)，空间复杂度为O(1)：
牛客网：链表中倒数最后k个节点
题目地址：
链表中倒数最后k个结点
在此题中可以直接设置两个指针fast，slow。让fast指针先向前移动k-1个节点，再一起移动fast和slow指针。当fast遍历完链表之后slow指针指向的就是链表中倒数第k个节点（此题要注意传让的k值是否合理，不然会造成越界访问）：
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k) {
if(pListHead==NULL)
return pListHead;
struct ListNode* fast=pListHead,*slow=pListHead;
for(k-1;k>0;k--)
{
if(fast==NULL)
return NULL;
fast=fast->next;
}
while(fast)
{
fast=fast->next;
slow=slow->next;
}
return slow;
}此方法只要遍历一次链表时间复杂度为O(n)，空间复杂度为O(1)：
LeetCode第21题：合并两个有序链表
题目地址：
21. 合并两个有序链表
在此题中，我使用了两个指针temp1和temp2分别遍历List1和List2链表，另给一个指针new接收temp1和temp2指针比较后的节点，谁的val值小就将该节点赋给new形成一个新链表：
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
if(list1==NULL&&list2==NULL)
return NULL;
else if(list1==NULL)
return list2;
else if(list2==NULL)
return list1;
struct ListNode* new=NULL,*temp1=list1,*temp2=list2;
if(temp1->val>temp2->val)
{
new=temp2;
temp2=temp2->next;
}
else
{
new=temp1;
temp1=temp1->next;
}
struct ListNode* head=new;
while(temp1&&temp2)
{
if(temp1->val>temp2->val)
{
new->next=temp2;
temp2=temp2->next;
new=new->next;
}
else
{
new->next=temp1;
temp1=temp1->next;
new=new->next;
}
}
if(temp1==NULL)
new->next=temp2;
else
new->next=temp1;
return head;
}此方法只需要遍历每个链表一次，时间复杂度为O(n)，空间复杂度为O(1)：
牛客网：分割链表
题目地址：
链表分割_牛客题霸_牛客网
这道题目在原链表上进行操作将会异常复杂繁琐，所以我们的操作是创建两个带哨兵位的头节点的链表：greater 和 less。（选择创建带哨兵位头节点的链表是为了方便改变头节点下一个节点，否则修改新链表头节点时较麻烦。）greater后面跟大于x的结点，less后面跟小于x的结点。我们只需让less的尾结点接上greater的头结点即可。这样既实现了分割又保证原数据的顺序不被改变：
class Partition {
public:
ListNode* partition(ListNode* pHead, int x)
{
ListNode* greaterhead, *greatertail, *lesshead, *lesstail;
greatertail = greaterhead = (ListNode*)malloc(sizeof(ListNode));
lesstail = lesshead = (ListNode*)malloc(sizeof(ListNode));
ListNode* cur = pHead;
while(cur)
{
if(cur->val < x)
{
lesstail->next = cur;
lesstail = lesstail->next;
}
else
{
greatertail->next = cur;
greatertail = greatertail->next;
}
cur = cur->next;
}
greatertail->next = NULL;
lesstail->next = greaterhead->next;
return lesshead->next;
}
};
该方法只需要遍历一次链表，时间复杂度为O(n)，空间复杂度为O(1):
牛客网：链表的回文结构
题目地址：
链表的回文结构_牛客题霸_牛客网
对于该题我先用快慢指针找到链表的中间节点将其赋予指针slow（在这里要判断链表节点的寄偶数），再将slow之前的节点用迭代法反转形成一个新的链表reverse，接着将reverse链表与slow链表相对应的节点数据值相比较（这里如果整个链表的节点数为奇数，slow要指向下一个节点），如果一一对应就是回文结构了：
class PalindromeList {
public:
bool chkPalindrome(ListNode* A) {
if (A == NULL || A->next == NULL)
return false;
ListNode* slow = A, *fast = A, *reverse = NULL, *temp = A, *New = NULL;
int i = 0;
while (fast)
{
fast = fast->next;
if (fast == NULL)
{
i++;
break;
}
fast = fast->next;
slow = slow->next;
}
while (temp != slow)
{
New = temp;
temp = temp->next;
New->next = reverse;
reverse = New;
}
if (i != 0)
{
slow = slow->next;
}
while (slow) {
if (slow->val != reverse->val)
return false;
slow = slow->next;
reverse = reverse->next;
}
return true;
}
};该方法需要遍历两次链表，时间复杂度为O(n),空间复杂度为O(1)：
LeetCode第160题：相交链表
题目地址：
160. 相交链表
对于该题我们看图可知，如果两链表相交，它们到最后相同的节点数一定是一样的，那我们不妨计算出每个链表的节点总数，再相减其节点总个数算出差值，接着让节点数多的一条链表先遍历差值个数的节点数，最后两个链表再一起同时遍历，终有一个节点是它们第一次相交的节点：
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
if(headA==NULL||headB==NULL)
return NULL;
struct ListNode*h1=headA,*h2=headB;
int A=0,B=0;
while(h1)
{
A++;
h1=h1->next;
}
while(h2)
{
B++;
h2=h2->next;
}
int c=A>B?A-B:B-A;
if(A>B)
{
while(c--)
{
headA=headA->next;
}
}
else
{
while(c--)
{
headB=headB->next;
}
}
while(headA)
{
if(headA==headB)
return headA;
headA=headA->next;
headB=headB->next;
}
return NULL;
}LeetCode第141题：环形链表
题目地址：
141. 环形链表
在判断链表结构是否为环形链表时，我们可以用快慢指针的方法。设定fast和slow指针，fast每次走两个节点，slow每次走一个节点，当链表为环形的时，slow和fast都进入了环形结构就变成了追击问题。它们之间的速度差始终为1，只要时间足够它们总能相遇（其他的速度差不能保证它们之间会相遇，具体要看环形结构，所以速度差为1是最保险的方法）：
bool hasCycle(struct ListNode *head) {
struct ListNode*fast=head,*slow=head;
while(fast&&fast->next)
{
fast=fast->next;
if(fast==slow)
return true;
fast=fast->next;
if(fast==slow)
return true;
slow=slow->next;
}
return false;
}LeetCode第142题：环形链表II
题目地址：
142. 环形链表 II
该题在上一题的基础上增加了一个条件：返回链表开始入环的第一个节点。
对此我们可以故技重施，照上一题快慢指针的方法先判断链表是不是环状结构，如果是就返回fast和slow相遇的节点，如果不是则返回空。是环状结构呢，我们将fast和slow相遇的节点“剪断”，即将相遇的节点的next置空（但是这里要提前保存next指针指向的节点，方便我们找链表开始入环的第一个节点）。这样该链表就被“剪”成了一个相交链表，链表的尾节点就是fast和slow相遇的节点，而相交的起始节点就是链表开始入环的第一个节点：
现在我们就可以看成两个单链表的相交问题了，还是使用LeetCode第160题的方法找到它们相交的节点：
struct ListNode* returnnode(struct ListNode *head)
{
struct ListNode*fast=head,*slow=head;
while(fast&&fast->next)
{
fast=fast->next;
if(fast==slow)
return fast;
fast=fast->next;
if(fast==slow)
return fast;
slow=slow->next;
}
return NULL;
}
struct ListNode* findnode(struct ListNode *head,struct ListNode *nextnode)
{
struct ListNode*h1=head,*h2=nextnode;
int A=0,B=0;
while(h1)
{
A++;
h1=h1->next;
}
while(h2)
{
B++;
h2=h2->next;
}
int c=A>B?A-B:B-A;
if(A>B)
{
while(c--)
{
head=head->next;
}
}
else
{
while(c--)
{
nextnode=nextnode->next;
}
}
while(head)
{
if(head==nextnode)
return head;
head=head->next;
nextnode=nextnode->next;
}
return NULL;
}
struct ListNode *detectCycle(struct ListNode *head) {
struct ListNode* cutnode=returnnode(head);
if(cutnode==NULL)
return NULL;
struct ListNode* nextnode=cutnode->next;
cutnode->next=NULL;
return findnode(head,nextnode);
}该方法的时间复杂度为O(n),空间复杂度为O(1)：
LeetCode第138题：复制带随机指针的链表
题目地址：
138. 复制带随机指针的链表
咋一眼看到这个题目感觉好复杂，直接暴力求解，先将整个链表拷贝一份，再慢慢一个一个来还原节点中的random指针：
struct Node* BuySListNode(int x) {
struct Node* p = (struct Node*)malloc(sizeof(struct Node));
p->random = NULL;
p->val = x;
p->next = NULL;
return p;
}
void CapyNode(struct Node** pplist, int x) {
struct Node* newplist = BuySListNode(x);
if (*pplist == NULL)
{
*pplist = newplist;
return;
}
struct Node* tail = *pplist;
while (tail->next) {
tail = tail->next;
}
tail->next = newplist;
}
void CapyRandom(struct Node** pplist, struct Node* Head, struct Node* node, struct Node* head)
{
if (node->random == NULL)
{
(*pplist)->random = NULL;
return;
}
while (head)
{
if (node->random == head)
{
(*pplist)->random = Head;
return;
}
head = head->next;
Head = Head->next;
}
}
struct Node* copyRandomList(struct Node* head) {
struct Node* Copy = NULL, * temp = head;
while (temp) {
CapyNode(&Copy, temp->val);
temp = temp->next;
}
temp = head;
struct Node* Head = Copy;
while (Copy)
{
CapyRandom(&Copy, Head, temp, head);
Copy = Copy->next;
temp = temp->next;
}
return Head;
}
这种方法时间复杂度为O(n^2)，不太理想：
下面我们用另一种方法来将时间复杂度改善到O(n):
比如现在有一原链表：
每次遍历一个节点将复制开辟的节点链接在原节点的next指针上，再将复制的节点的next指针指向原链表节点的next节点（红色的为新开辟的复制节点）：
接着（只要random不是空指针）在我们再一次遍历原链表时直接找到原节点的random指针，而在random指针指向的节点的next指针就是我们复制节点的random指针所要指向的节点了。如此一来我们就不用一个一个挨个的去找random指针的指向了：
最后再将复制的节点在原链表上取下就完成了复制链表的复制了：
代码如下：
struct Node* BuySListNode(int x) {
struct Node* p = (struct Node*)malloc(sizeof(struct Node));
p->random = NULL;
p->val = x;
p->next = NULL;
return p;
}
void CapyNode(struct Node** pplist) {
struct Node* newplist = BuySListNode((*pplist)->val);
newplist->next=(*pplist)->next;
(*pplist)->next=newplist;
}
void CapyRandom(struct Node*head)
{
struct Node*list=head;
while(list)
{
if(list->random)
list->next->random=list->random->next;
list=list->next->next;
}
}
struct Node* copyRandomList(struct Node* head) {
if(head==NULL)
return NULL;
struct Node*temp=head;
while (temp) {
CapyNode(&temp);
temp = temp->next->next;
}
CapyRandom(head);
struct Node*copy=(struct Node*)malloc(sizeof(struct Node));
struct Node*new=copy;
while(head)
{
copy->next=head->next;
head=head->next->next;
copy=copy->next;
}
return new->next;
}该方法需要遍历三次链表，时间复杂度为O(n)：
本次的链表题目合集就到此为止了，希望可以帮得上各位~