快慢指针的概念及其应用

一.概念

快慢指针中的快慢是指移动的步长，及每次向前移速度的快慢。例如：快指针每次沿链表向前移动2，慢指针每次向前移动1.

二.应用

• 判断单链表是否有环
  假设链表存在环，此时定义两个指针，一个指针每次向前移动两个位置（快指针），另一个指针每次向前移动一步（慢指针），若快指针到达NULL，则说明链表以NULL结尾，没有环。如果快指针追上慢指针，则表示该链表有环。
  代码实现：

#include <iostream>
using namespace std;
//结点结构体
typedef struct Node
{
    char c;
    struct Node *next;
}Node, *LinkList;
//打印链表
void PutOut(LinkList H)
{
    LinkList p;
    p = H->next;
    while (p)
    {
        cout << p->c << "  ";
        p = p->next;
    }
    cout << endl;
}
//判断链表是否有环
bool HasLoop(Node *H)
{
    Node *slow = H;
    Node *fast = H;
    while (fast->next != NULL)
    {
        slow = slow->next;       //慢指针每次移动一步
        fast = fast->next->next; //快指针每次移动两步
        //相遇，有环
        if (slow == fast)
        {
            cout << "此链表有环！" << endl;
            return true;
        }
    }
    //快指针到达链表尾，没有相遇，无环
    if (fast->next == NULL)
    {
        cout << "此链表无环！" << endl;
        return false;
    }
}

int main(void)
{
    //创建一个无环链表用于进行验证
    LinkList H = new Node();
    Node d = { 'd', NULL };
    Node c = { 'c', &d };
    Node b = { 'b', &c };
    Node a = { 'a', &b };
    H->next = &a;
    PutOut(H);
    HasLoop(H);

    //创建一个有环链表用于验证
    LinkList New_H = new Node();
    Node A, B, C, D;
    A.c = 'A';
    B.c = 'B';
    C.c = 'C';
    D.c = 'D';
    New_H->next = &A;
    A.next = &B;
    B.next = &C;
    C.next = &D;
    D.next = &B;

    HasLoop(New_H);

    return 0;
}

• 在有序链表中寻找中位数
  原理：由于快指针的移动速度是慢指针的2倍，所以当快指针到达链表尾时，慢指针正好到达链表中点。可以不借助计数器实现寻找中位数的功能。
• 输出链表中的倒数第K个结点
  原理：定义两个指针，第一个指针从链表的头指针开始遍历向前走k-1步，第二个指针保持不动；从第k步开始，第二个指针也开始从头指针遍历，由于两个指针的距离保持在k-1,当第一个指针到达链表尾时，第二个指针正好指向链表的倒数第k个结点。
  代码实现：

#include <iostream>
#include <malloc.h>
using namespace std;
/*
若第一个指针先走 K 步，则两个指针同时移动时的循环条件是while(p != NULL)
若第一个指针先走 K-1 步，则两个指针同时移动时的循环条件是 while(p->next != NULL)
*/
typedef struct Node
{
    char c;
    struct Node *next;
}Node, *LinkList;

void PutOut(LinkList H)
{
    LinkList p;
    p = H->next;
    while (p)
    {
        cout << p->c << "  ";
        p = p->next;
    }
    cout << endl;
}

void Rec_K(LinkList L, int K)
{
    LinkList pre, late;
    pre = L;
    late = L;
    int i;

    for (i = 0; i < K-1; ++i)
    {
        pre = pre->next;
    }
    while (pre->next != NULL)
    {
        pre = pre->next;
        late = late->next;
    }
    cout << "倒数第" << K << "个结点的值为" << late->c << endl;
}
int main(void)
{
    LinkList H = new Node();
    Node d = { 'd', NULL };
    Node c = { 'c', &d };
    Node b = { 'b', &c };
    Node a = { 'a', &b };
    H->next = &a;
    PutOut(H);
    Rec_K(H, 2);

    return 0;
}

• 判断两个单向链表是否相交，若相交，找出它们的第一个公共结点
  原理：分别遍历两个链表到末尾，若末尾结点相同，则说明它们相交，否则不相交。
  代码验证：

#include <iostream>
using namespace std;

typedef struct NODE
{
    int data;
    struct NODE *next;
}Node,*LinkList;
//链表初始化
LinkList InitList()
{
    LinkList H;
    H = (LinkList)malloc(sizeof(LinkList));
    H->next = NULL;
    return H;
}
//创建两条相交链表（V形或者Y形，不可能是X形，因为相交后，后续结点都一致）
//再创建一条与之都不相交的链表来进行验证
void CreatByTail_X(LinkList A, LinkList B, LinkList C)
{
    int i = 1, j = 1, k = 1;
    Node *pA, *pB, *pC, *tail_A, *tail_B, *tail_C;
    tail_A = A;
    tail_B = B;
    tail_C = C;

    //建立链表A
    while (i <= 5)
    {
        pA = (Node*)malloc(sizeof(Node));
        pA->data = i + 3;
        pA->next = tail_A->next;
        tail_A->next = pA;
        tail_A = tail_A->next;
        i++;
    }
    tail_A->next = NULL;

    //建立链表B
    while (j <=3 )
    {
        pB = (Node*)malloc(sizeof(Node));
        pB->data = j;
        tail_B->next = pB;
        tail_B = tail_B->next;
        j++;
    }
    //使pA从头结点开始后移，记录第四个结点位置，让tail_B指向它，则构成相交链表
    i = 0;
    pA = A;
    while (i < 4)
    {
        pA = pA->next;
        i++;
    }
    tail_B->next = pA;

    //建立链表C
    while (k <= 6)
    {
        pC = (Node*)malloc(sizeof(Node));
        pC->data = k;
        pC->next = tail_C->next;
        tail_C->next = pC;
        tail_C = tail_C->next;
        k++;
    }
    tail_C->next = NULL;
}
void PutOut(LinkList L)
{
    Node *p;
    p = L->next;
    while (p != NULL)
    {
        cout << p->data << " -> ";
        p = p->next;
    }
    cout << "\b\b\b\b    " << endl;
}
void Is_InterSert(LinkList _A, LinkList _B)
{
    Node *_pA, *_pB;
    _pA = _A;
    _pB = _B;
    while (_pA != NULL && _pB != NULL)
    {
        //使两条链表的指针同时向后移动，若在某一处指向相同，则链表相交
        _pA = _pA->next;
        _pB = _pB->next;
        if (_pA == _pB)
        {
            cout << "相交了！" << endl;
            break;
        }
    }
    if (_pA != _pB)
    {
        cout << "未相交！" << endl;
    }
}
int main(void)
{
    LinkList A;
    A = InitList();
    LinkList B;
    B = InitList();
    LinkList C;
    C = InitList();

    CreatByTail_X(A, B, C);

    cout << "链表A：" << endl;
    PutOut(A);
    cout << "链表B：" << endl;
    PutOut(B);
    cout << "链表C：" << endl;
    PutOut(C);

    cout << "A 与 B";
    Is_InterSert(A, B);
    cout << "A 与 C";
    Is_InterSert(A, C);
    cout << "B 与 C";
    Is_InterSert(B, C);
    return 0;
}