代码随想录算法训练营第四天-链表的删除和交换位置

第一题

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

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

示例1：

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

public ListNode swapPairs(ListNode head) {
       if (head == null) {
            return head;
        }
        ListNode res = new ListNode(-1,head);
        ListNode curr = res;
        while (curr.next != null && curr.next.next != null) {
            ListNode nextNext = curr.next.next; //保存之后的节点
            ListNode next = curr.next;//保存需要被移动的节点

            curr.next = nextNext;
            next.next = nextNext.next;
            nextNext.next = next;
            curr = next;
        }
        return res.next;
    }

关键处理分为三步：

• 第一步 ： 因为是两个节点交换位置，所以将虚拟节点位置指向第二点节点
• 第二步：第二个节点指向第一个节点
• 第三步：第一个结点指向第二个节点的后一个节点，移动当前节点位置

第二题

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

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

示例1：

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

public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode vir = new ListNode(-1,head);//设置一个虚节点，方便处理删除头节点的情况

        ListNode slow = vir;//定义快慢指针
        ListNode fast = vir;
        while (n-- > 0){//因为删除的是倒数第n个节点。所以让快指针，先走n步
            fast = fast.next;
        }

        while (fast.next != null){//快指针直到头，跳出
            slow = slow.next;
            fast = fast.next;
        }//此时得到的慢指针为删除指针的前一节点
        slow.next = slow.next.next;//下一个节点和下下节点连接
        return vir.next;
    }

• 关键点在于，快慢指针的节点位置差值为n。

第三题

leetcode 面试题 02.07. 链表相交

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

示例1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //转换为数学问题
        //假设A、B链表的祖成部分都是由私人部分和公有部分，两部分组成
        //A 私有长度 a 、 公有长度 c
        //B 私有长度 b 、 公有长度 c
        //那么只要我们遍历(A) a + c + b  = (B) b + c + a;
        //我们首先遍历完A,B各自的链表，如果为空。则将节点改变 A 变成 B， B 变成 A ，这样可以实现上面的的等式
        ListNode curA = headA;
        ListNode curB = headB;
        while (curA != curB){
            curA = curA != null ? curA.next : headA;
            curB = curB != null ? curB.next : headB;
        }
        return curA;
    }

两种方法：

• 第一种：暴力模拟，直接统计两个链表的长度，通过计算差值，保持两个链表的长度是一样的，这样的话，如果一起开始遍历，那么如果相交，则一定会节点相等
• 第二种：巧妙拼接，起始原理也是和第一种类似，只是这里变换了下思维，具体看注释。

第四题

leetcode 142.环形链表II

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

示例1:

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

 public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;//快慢指针
            slow = slow.next;
            while (fast == slow){//如果相遇，一定还换
                ListNode start = head;
                ListNode end = fast;
                while (start != end){//如果有还，则一个从相遇点触发，一个从起始点出发，最后会在入环点相遇
                    start = start.next;
                    end = end.next;
                }
                return start;//返回后一次相遇的节点
            }
        }
        return null;
    }

• 被转换为数学问题了，具体证明可以参考leetcode 题解。
• 普通场景可以想明白

总结

• 链表问题需要保证思路
• 进行链表的位置变化处理还是有些薄弱