代码随想录DAY4| 24.两两交换链表元素 19.删除倒数第N个节点 面试题02.07.链表相交 142.环形链表II

 24.两两交换链表中的节点

思路：定义一个虚拟头节点dummy，指针p 遍历链表，为了确定要操作的两节点，p的位置停在要交换的节点的前一个（p每次移动两位），还要提前保存这两节点的位置

struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode *dummy=malloc(sizeof(struct ListNode));
    struct ListNode *t1=NULL;
    struct ListNode *t2=NULL;
    struct ListNode *p=dummy;
    dummy->next=head;
    while(p->next&&p->next->next){
        t1=p->next->next;
        t2=p->next->next->next;
        p->next->next->next=p->next;
        p->next->next=t2;
        p->next=t1;
        p=p->next->next;
    }
    return dummy->next;
}

 19.删除倒数地N个节点

思路：双指针法：定义两个指针 fast 和 slow ,fast比 slow 提前走N步，当遍历结束时 slow 恰好在要删除节点的前一节点上（fast的位置有两种情况：fast->next=NULL或fast->next->next=NULL   ），就很容易地删除了。

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode *dummy=malloc(sizeof(struct ListNode));
    dummy->next=head;
    struct ListNode *fast=dummy;
    struct ListNode *slow=dummy;
    while(n--){
        fast=fast->next;
    }
    while(fast->next){
        fast=fast->next;
        slow=slow->next;
    }
    slow->next=slow->next->next;
    return dummy->next;
}

面试题 02.07.链表相交

思路：先遍历得到链表的长度，得到长度差x，fast 指向长的链表并且先走 x 步，slow 指向短链表表头，然后两指针同时往前走，当相遇时（即：fast=slow）时可判断链表相交，若遍历指针为空就退出循环，此时链表不相交

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int l1=0,l2=0;
    struct ListNode *lA=headA;
    struct ListNode *lB=headB;
    while(lA){
        lA=lA->next;
        l1++;
    }
    while(lB){
        lB=lB->next;
        l2++;
    }
    lA=headA;
    lB=headB;
    int l;
    if(l1>l2)
    {
    l=l1-l2;
    while(l--){
        lA=lA->next;
    }
    }
    else
    {
    l=l2-l1;
    while(l--){
        lB=lB->next;
    }
    }
    
    while(lA){
        if(lA==lB)
        return lA;
        lA=lA->next;
        lB=lB->next;
    }
    return NULL;
}

 142.环形链表II

思路：双指针法，定义两个指针 fast 和 slow ，fast 和 slow 同时出发，但是 fast 比 slow 多走一    步,若链表中有环，则：两指针必定相遇，即：fast=slow；这时， slow 指向 head ,fast 不动，两指针同时往前走，当两指针相遇时，它们一定都走了 a 步，相遇的点也就是环的入口；

分析：设：链表头到第一个交点的距离是 a ,环的长度是 b ; 相遇时 fast 走的路程是 slow 的两倍，             表示为：f=2s; fast 比 slow 多走了 n 圈，即：f=s+nb;

           上述两式得到：s=nb;

           从链表头一直向前走的步数是 k ，则：所有到环入口的步数公式表示为k=a+nb；   

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast=head;
    struct ListNode *slow=head;
    while(fast&&fast->next){
        fast=fast->next->next;
         slow=slow->next;
        if(fast==slow){
            fast=head;
            if(fast==slow)
            return fast;
            while(fast!=slow){
            fast=fast->next;
            slow=slow->next;
            if(fast==slow)
            return fast;        
        }
        }
        
    }
    return NULL;
}