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

本文链接：https://blog.csdn.net/DUM1615/article/details/127337349

代码随想录刷题Day4 | 24. 两两交换链表中的节点 |19.删除链表的倒数第N个节点 | 面试题 02.07. 链表相交 | 142.环形链表II | 总结

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

题目： 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例：

思路： 因为要交换节点的位置，所以我们首先引入头节点，方便后面的操作。改题目是成对的交换节点，因此我们标记要交换的两个节点的前一个节点pre和要交换的两个节点中的靠后的节点cur，靠前的节点tmp，交换的过程就很简单了，让pre.next=cur, cur.next=tmp, tmp.next=cur.next, cur=pre=tmp即可。

代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1, head);
        if(head == null || head.next == null) return head;
        ListNode pre = dummy, cur = dummy;
        int len = 0;
        while(cur.next != null){
            cur = cur.next;
            len++;
            if(len % 2 == 0 && len != 0){
                ListNode tmp = pre.next;
                pre.next = cur;
                tmp.next = cur.next;
                cur.next = tmp;
                cur = pre = tmp;
            }
        }
        return dummy.next;
    }
}

时间复杂度：O(n)，空间复杂度O(1)

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

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

示例：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

**思路：**设计一个快慢指针，当快指针走了n步之后，满指针才开始走，当快指针走到头时，慢指针指向要删除元素的前一个元素，也就是说在示例中快指针指向5时，慢指针指向3，那么此时让慢指针的next直接指向要删除元素的后一个元素即可。

代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1, head);
        ListNode fast = dummy, low = dummy;
        int flag = 0;
        while(fast.next != null){
            if(flag >= n){
                low = low.next;
            }
            fast = fast.next;
            flag++;
        }
        low.next = low.next.next;
        return dummy.next;
    }
}

时间复杂度：O(n)，空间复杂度O(1)

面试题 02.07. 链表相交

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

图示两个链表在节点 c1 开始相交：

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

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

思路： 首先注意是节点相等，而不是节点的数值相等！！！要找到两个链表相交的点，可以先遍历其中一个链表，然后将其中的节点存到数组中，然后遍历另一个数组的节点是否存在于该数组中，这样一来时间复杂度为O(m*n)，即便是用哈希表来存储也会造成额外空间的花销。我们首先遍历两个链表得到两个链表的长度，按照末尾对其两个链表，如下图所示（图片来源：代码随想录）

然后按照图中所示的位置开始遍历两个链表，如果节点相等，则返回该节点。

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0, lenB = 0;
        ListNode A = headA, B = headB;
        while(A != null){
            A = A.next;
            lenA++;
        }
        while(B != null){
            B = B.next;
            lenB++;
        }
        if(lenA >= lenB){
            int len = 0;
            while(headA != null){
                if(headA == headB){
                    return headB;
                }
                headA = headA.next;
                if(len >= lenA - lenB){
                    headB = headB.next;
                }
                len++;
            }
        }else{
            int len = 0;
            while(headB != null){
                if(headB == headA){
                    return headA;
                }
                headB = headB.next;
                if(len >= lenB - lenA){
                    headA = headA.next;
                }
                len++;
            }
        }
        return null;
    }
}

时间复杂度O(m+n)，空间复杂度O(1)

142.环形链表II

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

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

不允许修改链表

示例：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

思路： 参考代码随想录

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                ListNode index1 = fast, index2 = head;
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}