代码随想录day04

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

题目：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

          你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换

        完成此题的关键在于明确指针指向的顺序，在使用指针的过程中使用多个变量容易搞错，所以直接用cur一个指针，利用它的next去定位后面的节点，然后记录已经断链的节点即可。此外，需要注意while循环的条件，如果cur后面已经没有两个节点了，就可以停止了。 

struct ListNode* swapPairs(struct ListNode* head) {
    if(head==NULL||head->next==NULL) return head;
    struct ListNode* dummy=(struct ListNode *)malloc(sizeof(struct ListNode));
    dummy->next=head;
    struct ListNode* cur=dummy;
    while(cur->next!=NULL&&cur->next->next!=NULL){
        struct ListNode* nxt1=cur->next;
        struct ListNode* nxt2=cur->next->next->next;
        cur->next=cur->next->next;
        cur->next->next=nxt1;
        cur->next->next->next=nxt2;
        cur=cur->next->next;
    }
    return dummy->next;
}

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

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

 快慢指针

        设置一个虚头结点，让fast指针指向head，slow指针指向dummy，让fast先走n步，然后让fast和slow一起向后走，等fast指向null时，slow刚好指向倒数第n个节点的前驱，此时将倒数第n个节点删除即可。设置虚节点的作用是，如果链表中只有一个节点时，也能进行删除，而不需要单独处理了。

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummy=malloc(sizeof(struct ListNode));
    dummy->next=head;
    struct ListNode* fast=head;
    struct ListNode* slow=dummy;
    for(int i=0;i<n;++i){
           fast=fast->next;
    }
    while(fast!=NULL){//此时slow指向倒数第n个节点的前驱
        fast=fast->next;
        slow=slow->next;
    }
    slow->next=slow->next->next;
    return dummy->next;
}

160. 链表相交

题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

题目数据 保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

 1.暴力解法

计算出两个链表的长度，让长的一条先走，使得两个链表齐平，再进行遍历查找。

 int length(struct ListNode* head){
     if(head==NULL) return 0;
     int len=0;
     struct ListNode* p=head;
     while(p!=NULL){
         p=p->next;
         len++;
     }
     return len;
 }
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int lenA=length(headA),lenB=length(headB);
    struct ListNode* pa=headA,*pb=headB;
    if(lenA>lenB){
        int l=lenA-lenB;
        while(l--){
            pa=pa->next;
        }
    }else{
        int l=lenB-lenA;
        while(l--){
            pb=pb->next;
        }
    }
    while(pa!=pb){
        pa=pa->next;
        pb=pb->next;
    }
    return pa;
}

2.双指针法

此时有两种情况：

        一、两个链表相交，则pa与pb均会走相同的步数，并且最终指向同一个节点。若a链表为a+c，b链表为b+c，则两个指针均会走a+b+c步，然后指向相同节点。

        二、两个链表不相交，则pa与pb最终都会指向null。若a链表长m，b链表长n，则两个指针均走m+n步，最后指向null。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(headA==NULL||headB==NULL){
        return NULL;
    }
    struct ListNode *pa=headA,*pb=headB;
    while(pa!=pb){
        pa=pa==NULL?headB:pa->next;
        pb=pb==NULL?headA:pb->next;
    }
    return pa;
}

142.环形链表II

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

 此题有两问：

1、如何判断是否有环？

        快慢指针的思想：如果链表有环，则快慢指针一定相遇，如果没有环，则快指针会先指向null。

2、如何找环的入口？

        假设链表头节点到环入口的距离为x，环入口到相遇节点的距离为y，相遇节点到环入口的距离为 z，慢指针走过的距离为x+y，快指针走过的距离为x+y+k(y+z)，其中 k是快指针在环中绕的圈数。

        而且快指针走的距离是慢指针的2倍，因此能得到2×(x+y)=x+y+k×(y+z)，可以推出 x + y = k  (y + z)，即 x=(k−1)×(y+z)+z。

        如果令k=1，则x=z。也即是说，指向链表头的一个指针与慢指针一起向前走，那么它们一定会在环入口相遇。

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    while(fast!=NULL&&fast->next!=NULL){
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow){//此时fast与slow相遇，说明存在环，寻找入口
            struct ListNode* temp=head;
            while(temp!=slow){
                slow=slow->next;
                temp=temp->next;
            }
            return slow;
        }
    }
    return NULL;
}