【数据结构】07双指针技巧

Q1：环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例2：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

思路：设置快慢指针，若快指针能与慢指针碰头，则有环。

bool hasCycle(struct ListNode *head) {
    struct ListNode *p = head, *q = head;
    while(p && q && q->next){
        p = p->next;
        q = q->next->next;
        if(p == q){
           return true;
        }
    }
    return false;
}

Q2：环形链表||

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。
示例1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点
示例2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
思路
即：当两指针相遇时，把其中一个指针放回头节点位置，两指针每次向前走一步，其最终相遇到入环结点。

/**
 * 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;

    if(fast  == NULL || fast->next == NULL){
        return NULL;
    }

    while(fast && fast->next){
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow){
            printf("slow: %d, fast : %d\n", slow->val, fast->val);
            break;
        }
        
    }

    if(fast == slow){
        printf("slow: %d, fast : %d\n", slow->val, fast->val);
        fast = head;
        while(fast!=slow){
            printf("slow: %d, fast : %d\n", slow->val, fast->val);
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
    else{
        return NULL ;
    }
    
}

Q3：相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构

示例1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。
思路：遍历时，把B链连在A后，把A连在B后。找出从哪个结点开始后面的链表一样了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode * p1  = headA;
    struct ListNode * p2  = headB;
    int cnt1 = 0, cnt2= 0;

    while(p1 && p2){

        if(p1 == p2){
            return p1;
        }
        p1= p1->next;
        p2= p2->next;
        printf("p1: %d, p2:%d\n",p1->val, p2->val);
        
        if(p1 == NULL && cnt1 <1){
            p1 = headB;
            cnt1 ++;
            printf("headA: %d\n", headA->val);
            
        }
        if(p2 == NULL && cnt2 <2){
            //printf("headA: %d\n", headA->val);
            p2 = headA;
            cnt2++;
        }

        
    }
    
    return NULL;

    
}

Q4：删除链表倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    struct ListNode* t ;
    int i =0;

    while(i < n){
        fast = fast->next;
        i++;
    }
    if(fast == NULL){
        return head->next;
    }
    

    while(fast != NULL ){
        fast = fast -> next;
        t = slow;
        slow = slow->next;
    }

   
    t->next = slow->next;
    

    return head;

   


    
}

快指针向前移动n位，慢指针在表头不动。
当快指针到达表尾时，慢指针正好到达倒数第n位。