1.随机链表的复制
本题是一道经典的链表题,当我们学习完链表可以拿这道题来检验一下我们的学习成果!
接下来我们来看一下这道题,结合用例我们来理解一下:
大致的题意就是要我们建立一个新的链表,复制原链表 ,每个新节点的值和原节点的值相同,新节点的指针也都指向复制链表的新节点!
1.1大体思路
首先我们可以看出原链表中的random指针的指向是不固定的,可以指向NULL,可以指向任意位置,这也是本题最难解决的问题,但是也有一种巧妙的解决办法,就是把新节点插入到原链表每个节点的后面,这样做是为了拷贝节点和原链表建立关联关系。
1.把新节点插入到原链表每个节点的后面
2.控制random
3.将拷贝节点取下来尾插到新的链表中
接下来让我们一一实现!
1.2把新节点插入到原链表每个节点的后面
我们先来画图分析一下:
我们想要得到这样的一个链表, 那我们就可以用malloc申请新节点,写一个循环!
这样我们就把新节点插入到了链表的每一个节点后面
1.3 控制random
当我们把新节点插入到链表的每一个节点后面,这样拷贝节点就和原链表建立了联系,原链表的random怎么指,那么我们新节点的random就这么指,也就是新节点的random指向等于新节点random指向的下一个节点!
1.4将拷贝节点取下来尾插到新的链表中
这一部就很简单了,就是将我们拷贝的节点尾插到新链表中,我们学过单链表的尾插,思想和单链表尾插一样,不懂的可以看一下我的单链表博客!
1.5整体代码
/**
* Definition for a Node.
* struct Node {
* int val;
* struct Node *next;
* struct Node *random;
* };
*/
struct Node* copyRandomList(struct Node* head) {
//1.创建新节点
struct Node* cur = head;
while(cur)
{
struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
copy->val = cur->val;
copy->next = cur->next;
cur->next = copy;
cur = copy->next;
}
//2.修改random
cur = head;
while(cur)
{
struct Node* copy = cur->next;
if(cur->random == NULL)
{
copy->random = NULL;
}
else
{
copy->random = cur->random->next;
}
cur = copy->next;
}
//3.将链表分开
cur = head;
struct Node* copyhead = NULL, *copytail = NULL;
while(cur)
{
struct Node* copy = cur->next;
struct Node* next = copy->next;
if(copytail == NULL)
{
copyhead = copytail = copy;
}
else
{
copytail->next = copy;
copytail = copytail->next;
}
cur->next = next;
cur = next;
}
return copyhead;
}
2.环形链表
这道题就是判断链表是否带环,我们可以使用快慢指针来解这道题!就是创立两个指针,慢指针一次走一步,快指针一次走两步!当快指针等于慢指针证明带环!
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
bool hasCycle(struct ListNode *head) {
struct ListNode* solw = head;
struct ListNode* fast = head;
while(fast && fast->next)
{
solw = solw->next;
fast = fast->next->next;
if(solw == fast)
{
return true;
}
}
return false;
}
对于这道题,还有一些额外的思考
2.1额外的思考
1.为什么会相遇,会不会错过,会不会永远追不上 ?
2.solw一次走1步,fast一次走3步,4步,是否会追不上?如何证明
我们首先来解决第一个:
这个很好证明,因为每次追击距离-1,到0的时候追到相遇!
第二个问题fast一次走3步,一定可以追上
总结一下:
得出结论一定可以追上,我们也可以进行反证。N是奇数,C是偶数,第一轮追不上,下一轮追到,或者N和C都是偶数,那么第一轮就追到!
3.环形链表 II
通读题目,就是要找环形链表的入口点!
3.1大体思路:
1. 创立快慢指针,当慢指针等于快指针
2.再newhead创立一个指针从头开始走,创立一个meet指针从slow和fast相遇的地方走
3.当从newhead指针和meet指针相遇就是环形链表的入口
3.2详细分析
3.3整体代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *detectCycle(struct ListNode *head) {
struct ListNode* slow = head;
struct ListNode* fast = head;
while(fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
{
struct ListNode* newhead = head;
struct ListNode* meet = slow;
while(meet != newhead)
{
meet = meet->next;
newhead = newhead->next;
}
return meet;
}
}
return NULL;
}
总结:
第一题主要是链表的多方面考察,后面的两个题虽然代码比较简单,但是并不容易想到,要有一定的数理思想,可能不容易想到!