详解双指针算法（一）之快慢指针

详解双指针算法（一）之快慢指针

---

---

前言

根据问题的不同，对应有多种不同类型的双指针算法，这一期我主要讲解快慢指针算法

---

一、双指针基本介绍

1. 概念

双指针是一种巧妙的算法思想，常用于遍历数组或是链表；一般需要我们定义两个指针分别指向不同的位置，根据问题的需要来改变指针的走向。使用双指针算法可以极大简化算法的时间复杂度，提高程序的效率


注意： 这里的双指针并不是严格的指针类型，而是可以指向具体位置的变量，一般在数组中使用下标，在链表中使用链表的节点指针

2. 分类

一般的双指针问题可以分为如下几类：

• 一般类型的双指针（同向或反向，根据指针指向的数据决定指针的走向）
• 快慢双指针
• 滑动窗口（同向指针且根据窗口内维护的数据决定双指针的走向）

---

二、快慢指针之找特殊节点

1. 简介

快慢指针一般可以用来找特殊节点的位置，一般让快慢指针相隔一定距离，当快指针走到尾时，慢指针则停在你要找的位置上

2. 经典例题

• 删除链表的倒数第N个节点

题目来源



解析：该题目条件 1 <= N <= 链表长度，故先让快指针先走 k 步，然后让快慢指针同时走，当快指针走到链表的尾部时，慢指针停在倒数第 k 个节点

特殊情况： 删除节点为链表的头节点时，需要更改头节点

过程演示：

代码实现：

struct ListNode* removeNthFromEnd(struct ListNode* head, int n)
{
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    struct ListNode* prev=NULL;	// 记录删除节点的前驱结点，用来链接删除节点后的节点
    // 快指针先走 k 步
    while(n--)
    {
        fast=fast->next;
    }
    // 快指针走到尾，慢指针停在倒数第 N 个节点位置
    while(fast)
    {
        prev=slow;
        fast=fast->next;
        slow=slow->next;
    }
    // 特殊情况的处理
    if(slow==head)
    {
        head=head->next;
        free(slow);
    }
    else
    {
        prev->next=slow->next;
        free(slow);
    }
    return head;
}

• 链表的中间节点

题目来源


解析：要找到链表的中间节点，绝大部分同学的思路为先遍历一次链表算出长度，通过计算后再次遍历链表，返回中间节点；上一种方法需要遍历两次链表，并且需要对链表长度为单数还是双数做分类处理，而使用快慢指针的方法只需遍历一次链表，让快指针一次走两步，慢指针一次走一步，当快指针走到尾时，慢指针则停在题目需要的位置，也无需对链表长度做分类处理


过程演示：

代码实现：

struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    while(fast&&fast->next)
    {
        slow=slow->next;			// 慢指针一次走一步
        fast=fast->next->next;		// 快指针一次走两步
    }
    return slow;
}

---

三、快慢指针之环形问题

1. 简介

快慢指针还可以解决带环问题，例如判断链表是否带环，或返回链表入环的第一个节点

2. 经典例题

• 判断环形链表

题目来源



解析：定义两个快慢指针，慢指针一次走一步，快指针一次走两步，如果链表带环，快慢指针肯定会在环中节点处相遇


过程演示：

代码实现：

bool hasCycle(struct ListNode *head) 
{
    struct ListNode * slow=head;
    struct ListNode * fast=head;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)		// 相遇则链表带环
        return true;
    }
    return false;			// 快指针走到空则链表不带环
}

• 判断快乐数

题目来源



解析：尽管一个数是不是快乐数，在经历上述转换都会形成一个环，区别在于快乐数形成的环中数全为 1 ，非快乐数形成的环中数全不为 1 ，则可以用到快慢指针的方法判断相遇处，即环中数是否为 1 ，如果为 1 则是快乐数，反之不是快乐数


此题目的双指针并不是严格意义上的指针，而是用两个变量，fast 变量一次进行两次转换，slow 变量一次进行一次转换，两变量相等即为在环中相遇，判断相遇的数是否为 1


过程演示：

代码实现：

int sum(int n)
{
    int sum=0;
    while(n)
    {
        sum += (n % 10) * (n % 10);
        n/=10;
    }
    return sum;
}

bool isHappy(int n) 
{
    int slow=n,fast=sum(n);
    while(slow!=fast)
    {
        slow=sum(slow);
        fast=sum(sum(fast));
    }
    return slow==1;
}

• 判断环形链表并返回入环节点

题目来源

解析：快指针一次走两步，慢指针一次走一步，记录相遇位置，即判断链表带环位置；再让一个指针从链表起始位置开始遍历链表，同时让一个指针从相遇点的位置开始绕环运行，两个指针均每次走一步，最终肯定会在环的入口点相遇

证明：

过程演示：

代码实现：

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(fast==slow)
        {
            struct ListNode * meet=fast;		// 一个节点从链表初始点出发
            struct ListNode * inter=head;	    // 一个节点从判环位置出发
            while(1)
            {
                if(meet==inter)		// 有环肯定相遇，相遇位置为入环第一个节点
                return inter;
                meet=meet->next;
                inter=inter->next;
            }
        }
    }
    return NULL;
}

---