文章介绍了如何使用快慢指针解决链表中的经典问题，如查找中间节点、倒数第k个节点、反转链表、判断回文链表、相交链表以及环形链表的入口点。作者还提到递归和不同步长快指针在这些问题中的可能性。
链表有许多非常经典的题目，今天我们就来一起学习有关快慢指针应用的题目。
链表的中间结点
以常规方法来看，要先遍历链表，求出数组长度，之后再次遍历至中间结点，返回中间节点的地址。
typedef struct ListNode Node;
struct ListNode* middleNode(struct ListNode* head)
{
Node* cur = head;
int len = 0;
while(cur)
{
len++;
cur = cur->next;
}
int k = 0;
cur = head;
while(k < len / 2)
{
cur=cur->next;
k++;
}
return cur;
}此外，我们还可以用一个十分简洁的方法--快慢指针。
我们定义两个指针，一个一次走一步，另一个一次走两步。当快的一个走至结尾时，另一个恰好走至中间节点。
Node* slow = head,*fast=head;
slow = slow->next;
fast = fast->next->next;下面我们来分情况讨论：
如果链表为偶数个，则当fast走至结尾时，slow恰好走至中间结点。
如果链表为奇数个，则链表在最后一次时，只走一次便走至结尾，此时我们的程序会报错。所以我们要加上判定条件。
typedef struct ListNode Node;
struct ListNode* middleNode(struct ListNode* head)
{
Node* fast=head,*slow=head;
while(fast && fast->next)
{
slow=slow->next;
if(fast)
{
fast=fast->next->next;
}
}
return slow;
}链表的倒数第k个结点
很显然，直接求得链表的长度，减去k，再遍历列表，即可找到。
typedef struct ListNode Node;
int kthToLast(struct ListNode* head, int k)
{
Node* cur = head;
int len = 0;
while(cur)
{
len++;
cur = cur->next;
}
int i = 0;
cur = head;
while(i < len-k)
{
cur = cur->next;
i++;
}
return cur->val;
}此外，我们就用快慢指针的方式来解决问题。
先定义两个指针，其中一个先走k-1步，之后再两个同时进行，直至先走的指针走至结尾，即可得到倒数第k个结点。
typedef struct ListNode Node;
int kthToLast(struct ListNode* head, int k)
{
Node* slow=head,*fast=head;
int i = 0;
for(i = 0;i < k;i++)
{
fast=fast->next;
}
while(fast)
{
slow=slow->next;
fast=fast->next;
}
return slow->val;
}反转链表
一般我们所能想到的办法便是创建一个新的链表，然后将数据不断头插至新的链表中。
typedef struct ListNode Node;
struct ListNode* reverseList(struct ListNode* head)
{
if(head == NULL)
{
return head;
}
Node* cur=head;
Node* newhead=NULL,*newtail=NULL;
while(cur)
{
if(newhead==NULL)
{
newhead=newtail=cur;
}
else
{
Node* newnode=(Node*)malloc(sizeof(Node));
newnode->val=cur->val;
newnode->next=newhead;
newhead=newnode;
}
cur=cur->next;
}
//将尾节点置为空，若不置为空，则后边将继续打印至原链表的尾
//因为是头插，所以newtail的next会链接至原链表的第二个节点
newtail->next=NULL;
return newhead;
}此外，我们还有一种更为简便的方法，我们定义三个指针，第一个指向空，第二个指向头节点，第三个指向头结点的下一个节点。然后进行循环，每次将n2的next指向n1，接着将n2的值赋给n1，n3的值赋给n2，将n3指向下一个节点。直至n2 走到空。
值得注意的是，当最后一次是，n3 已经走到了空，因此，我们要给n3加上限定条件，防止程序出错。
typedef struct ListNode Node;
struct ListNode* reverseList(struct ListNode* head)
{
if(head == NULL)
{
return head;
}
Node* n1=NULL,*n2=head,*n3=head->next;
while(n2)
{
n2->next=n1;
n1=n2;
n2=n3;
if(n3)
{
n3=n3->next;
}
}
return n1;
}当然，在做链表相关的题目时，我们一定要考虑链表为空的情况
回文链表
要判断是否回文，我们就要进行比较，从给出的题目是里就可以看出，我们要将第一个与最后一个相比，第二个与倒数第二个相比，直至比到两者位置相同。最简单的方式，我们直接将链表的值储存在相对应的数组中。
typedef struct ListNode Node;
bool isPalindrome(struct ListNode* head)
{
Node* cur=head;
int arr[100000];
int i=0;
while(cur)
{
arr[i++]=cur->val;
cur=cur->next;
}
int j=i-1;
for(i=0;i<j;i++,j--)
{
if(arr[i] != arr[j])
{
return false;
}
}
return true;
}非常的简单粗暴，但却是可以实际的解决问题。
那有没有另外的方法？肯定是有的，既然我们本篇文章是讲快慢指针的，那必然是有办法将其用快慢指针的方法解出。
我们可以先寻找链表的中间节点，然后对包括中间节点之后的链表进行反转，之后直接两两比较直至其中一个走到空。而寻找中间结点和反转链表正是上方我们已学习过的，这样我们的代码就能十分简单的便构思出来。
typedef struct ListNode Node;
Node* FindMidNode(Node* head)
{
Node* slow=head,*fast=head;
while(fast && fast->next)
{
slow=slow->next;
if(fast)
{
fast=fast->next->next;
}
}
return slow;
}
Node* ReverseNode(Node* head)
{
Node* n1=NULL,*n2=head,*n3=head->next;
while(n2)
{
n2->next=n1;
n1=n2;
n2=n3;
if(n3)
{
n3=n3->next;
}
}
return n1;
}
bool isPalindrome(struct ListNode* head)
{
Node* mid = FindMidNode(head);
Node* ret = ReverseNode(mid);
Node* cur=head;
while(cur && ret)
{
if(cur->val != ret->val)
{
return false;
}
cur=cur->next;
ret=ret->next;
}
return true;
}相交链表
判断链表是否相交，并返回相交的起始节点。首先，我们可以直接暴力解法，利用双层循环进行判断。
typedef struct ListNode Node;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
Node* curA = NULL,*curB = NULL;
for(curA = headA; curA != NULL; curA = curA->next)
{
for(curB = headB; curB != NULL; curB = curB->next)
{
if(curA == curB)
{
return curA;
}
}
}
return NULL;
}除此之外，我们还可以用一种时间复杂度更低的方法。
先遍历链表，求出链表长度。然后使长的一个先走一段路（相差步数），之后让两个一起走至相交处，若走到了最后，就返回空指针。
typedef struct ListNode Node;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
Node* curA = headA,*curB = headB;
int countA=0,countB=0;
//使用curA->next作为判定条件，可以正确判定个数
//同时能将最后一个位置最为判定条件，判断是否相交
while(curA->next)
{
countA++;
curA=curA->next;
}
while(curB->next)
{
countB++;
curB=curB->next;
}
if(curA!=curB)
{
return NULL;
}
Node* ShortNode=headA,*LongNode=headB;
if(countA>countB)
{
ShortNode=headB;
LongNode=headA;
}
int k=abs(countA-countB);
while(k--)
{
LongNode=LongNode->next;
}
while(ShortNode!=LongNode)
{
LongNode=LongNode->next;
ShortNode=ShortNode->next;
}
return ShortNode;
}环形链表
要判断是否为环形链表，很显然，我们可以使用快慢指针来解决。
我们让慢指针一次走一步，快指针一次走两步，当快指针与慢指针指向同一个位置时，说明有环。若快指针走到空，则没有环。
typedef struct ListNode Node;
bool hasCycle(struct ListNode *head)
{
Node* slow = head,*fast = head;
while(fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
{
return true;
}
}
return false;
}
环形链表||
基于上题，这次不仅要判断是否有环，而且要判断环的入口点是哪里。我们依然用上边的方法判断是否有环，之后再让一个从入口点开始，一个从相遇点开始，当两者相遇时，就是环的入口点。
typedef struct ListNode Node;
struct ListNode *detectCycle(struct ListNode *head)
{
Node* slow=head,*fast=head;
while(fast && fast->next)
{
slow=slow->next;
fast=fast->next->next;
if(slow==fast)
{
Node* meet=slow,*cur=head;
while(cur!=meet)
{
cur=cur->next;
meet=meet->next;
}
return meet;
}
}
return NULL;
}
总结
以上是一些有关快慢指针的一些问题，十分经典。
此外，我们还可以再思考一些问题。
回文链表这个问题如果要使用递归要如何做？
环形链表的快慢指针，如果快指针一次走三步呢？一次走四步呢？那他们还能否相遇呢?
扫一扫
866
到【灌水乐园】发言
