[代码随想录Day4打卡] 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点面试题 02.07. 链表相交 142.环形链表II 总结-优快云博客

本文链接：https://blog.youkuaiyun.com/goodenough5/article/details/143469978

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

题目：
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
在这里插入图片描述
重点：

明确具体交换怎么做。交换其中1，2节点的示意图如下所示，总共有三步。但是在进行步骤一的时候会丢失cur->next的值，进行步骤2会丢失cur->next->next->next的值，进行步骤三虽然会丢失cur->next->next的值但是这个值我们是在第一步使用不是在后面步骤中使用，所以已经把它放到相应位置了。总体来说我们需要保存cur->next值和cu->next->next->next这两个节点。
所以伪代码如下：

temp = cur.next;
temp1 = cur->next->next->next;
cur->next = cur->next->next;
cur->next->next = temp;
temp->next = temp1;
cur = cur->next->next;//移动两步

在这里插入图片描述

2. 明确循环的结束条件。对于链表长度为偶数的话，就是 $c u r - > n e x t == N u ll$ ，对于链表长度为奇数的，就是 $c u r - > n e x t - > n e x t == N u ll$ 。所以终止条件是 $c u r - > n e x t == N o n e ∣∣ c u r - > n e x t - > n e x t == N u ll$ ，转换成程序就是while(cur->next!=Null && cur->next->next!=Null):
明确上面两个步骤就好写了，为了操作统一加上虚拟头节点。
下面是JAVA和Python代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
        //建立虚拟头节点
        ListNode dummyhead = new ListNode(-1);
        dummyhead.next = head;
        ListNode cur = dummyhead;
        while(cur.next!=null && cur.next.next!=null){
            ListNode temp = cur.next;
            ListNode temp1 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp;
            temp.next = temp1;
            cur = temp;
        }
        return dummyhead.next;
    }
}

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        dummy_head = ListNode(next=head)#设置虚拟头节点
        cur = dummy_head
        while(cur.next!=None and cur.next.next != None):
            temp = cur.next
            temp1 = cur.next.next.next#保存下一个节点和下下个节点
            cur.next = cur.next.next
            cur.next.next = temp
            temp.next = temp1
            cur = temp
        return dummy_head.next

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

重点：删除链表中一个节点的时候需要定位到该节点的上一个节点。
思路：使用双指针，一个快指针一个慢指针，快指针先移动n+1步（为了获得被删除节点的前一个节点），然后快慢指针一起向前移动。
删除操作就是:slow->next = slow->next->next。（就把slow->next删除了，即被删除节点）

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyhead = new ListNode(-1);
        dummyhead.next = head;
        ListNode fast = dummyhead;
        ListNode slow = dummyhead;
        n++;
        while(n>0 && fast != null ){
            fast = fast.next;
            n--;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;//删除指针的操作
        return dummyhead.next;
    }
}

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: Optional[ListNode]
        :type n: int
        :rtype: Optional[ListNode]
        """
        dummyhead = ListNode(-1)
        dummyhead.next = head
        n+=1
        fast = dummyhead
        slow = dummyhead
        while(n>0 and fast!=None):
            fast = fast.next#先移动N+1步
            n-=1
        
        while(fast!=None):
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummyhead.next

面试题 02.07. 链表相交

重点：

是链表相等，不是值相等listnode1==listnode2就可以直接return listnode1(listnode2也可以)。
链表相交就是末尾的node都相同，需要末尾对齐，需要知道两个链表的长度。（刚开始一头雾水，后来看讲解明白了。）
看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

否则循环退出返回空指针。

PS:这个解释就直接抄代码随想录上的了。（(●’◡’●)）

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while(curA != null){
            lenA++;//求链表A的长度
            curA = curA.next;
        }
        while(curB != null){
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if(lenB > lenA){
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        //交换是为了让A永远是长度最大的方便后续统一进行操作
        //求长度差
        int gap = lenA-lenB;
        //让curA和curB在同一起点上（末尾位置对齐）
        while(gap-->0){
            curA = curA.next;
        }
        //遍历curA和curB，遇到相同的则之间返回
        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;

    }
}

下面这个可以想象两个列表长度不相同，那么就是其中指针A先遍历完短的链表之后，再到长链表中，当指针B遍历完长的链表到短的链表上的时候，两个链表就实现了末尾对齐。（A指针在长链表的倒数len(短链表)的位置）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //方法二合并链表
        ListNode p1 = headA, p2 = headB;
        while(p1!=p2){
            //p1走一步，如果走到A链表的末尾，转换到B链表
            //极端情况就是A,B没有交点，而且长度不相等，p1和p2走完两个链表
            if(p1==null) p1 = headB;
            else p1 = p1.next;
            //p2也是，如果走到B链表的末尾就转换到A链表
            if(p2 == null) p2 = headA;
            else p2 = p2.next;
        }
        return p1;//p2也可以
    }
}

Python有不同的方法，我感觉思想应该相同就只看了一个。

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        #求长度，同时出发
        lenA, lenB = 0, 0
        cur = headA
        while cur:
            cur = cur.next
            lenA += 1
        cur = headB
        while cur:
            cur = cur.next
            lenB += 1
        curA, curB = headA, headB
        if lenA > lenB:
            curA, curB = curB, curA
            lenA, lenB = lenB, lenA 
        for _ in range(lenB - lenA): #让母后curA金额curB在末尾位置对齐
            curB = curB.next
        while curA:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next
        return None

142.环形链表II

需要数学推导。
重点：

判断有环：定义快慢指针，快指针每次移动两步，慢指针每次移动一步（两者相对速度为1），如果快慢指针相遇说明有环。
找到环的入口：两个指针从头节点和快慢指针相遇的地方同时移动，交点就是环形入口节点，视频很详细，需要数学推导。

JAVA和Python代码如下：

public class Solution {
    public ListNode detectCycle(ListNode head) {//快慢指针
        ListNode fast = head;
        ListNode slow = head;
        
        while(fast != null && fast.next != null){
            fast = fast.next.next;//k快指针每次移动两步，慢指针每次移动一步，这样相对速度是1，一定可以在环内相遇
            slow = slow.next;
            if(fast == slow){
                ListNode index1 = fast;
                ListNode index2 = head;
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
        
    }
}

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        #下面这个是我根据伪代码写的
        fast = head
        slow = head
        while(fast!=None and fast.next!=None):
            fast = fast.next.next
            slow = slow.next
            if(fast == slow):#找到相遇点说明有环，找环的入口
                index1 = fast#相遇点
                index2 = head
                while(index1!= index2):
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None