代码随想录算法第四天|24. 两两交换链表中的节点|19. 删除链表的倒数第 N 个结点

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

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

 

 

解题思路：

①创建一个虚拟头节点，方便后续操作

②缓存next,将pre的next改为head的next,然后将head的next指向head,将head的next接上一开始缓存的next.然后pre=head;head = head.next，分别向后移动一位

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        while(pre.next != null && pre.next.next != null){
            ListNode tmp = head.next.next;
            pre.next = head.next;
            head.next.next = head;
            head.next = tmp;
            pre = head;
            head = head.next;
        }
        return dummyNode.next;
    }
}

 

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

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

如果要删除倒数第n个节点，首先让快指针先前进n步，然后快指针和慢指针同时向后移动，当快指针指向末尾的时候，慢指针此时刚好在倒数第n个位置，此时删除慢指针指向的节点就可以。但是，找到一个节点的上一个节点不是那么好操作，所以我们定义一个虚拟节点，让慢指针指向将要被删除的节点的上一个节点，此时，找到并删除慢指针指向的下一个节点就相对容易很多。

解题思路：

①定义一个虚拟节点，方便后续的操作

②定义两个指针，分别是快指针和慢指针

③fast首先走n + 1步 ，这样同时移动的时候slow指向的是删除节点的上一个节点（方便做删除操作）

④fast和slow同时移动，直到fast指向末尾

⑤删除slow指向的下一个节点

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

    }
}

面试题 02.07. 链表相交

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

注：交点不是数值相等，而是指针相等

解题思路：

①得出链表A和链表B的长度，然后计算出两条链表长度的差值。

②让链表A的指针移动，直到和链表B末尾对齐的位置

③此时比较链表A的指针curA和链表B的指针curB是否相等，

如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

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

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0;
        int lenB = 0;
        while(curA != null){
            lenA++;
            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 tmp = curA;
            curA = curB;
            curB = tmp;
        }
        int gap = lenA - lenB;
        while(gap-- > 0){
            curA = curA.next;
        }
        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
        
        
    }
}

142. 环形链表 II

问题描述：

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

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

这个问题需要分两步来解决：一是判断链表是否存在环，二是如果存在环，要怎么找到环的入口

一、判断链表是否有环：可以使用快慢指针，快指针每次走两个步长，慢指针每次走一个步长，这样就可以使得两个指针的相对速度为一，可以想象成慢指针在静止，快指针以每次一个步长移动，这样，如果链表存在环，则快慢指针必然会在环中相遇。此时，快指针先于慢指针进入环中，当慢指针进入时，形成了快指针追赶慢指针的情形。其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

二、找到环的入口：

假设头节点到环形节点的入口的步长为X，环形节点到相遇处的步长为Y，相遇处再到环形入口节点步长为Z，则快指针相遇时走过的步长和为：X + Y +n(Y+Z)    n>= 1；慢指针走到相遇处走过的步长和为X+Y。n指的是快指针走了n圈，这里的步长指的是节点数。

在这个环形链表中，快指针每一次走两个步长，慢指针每次走一个步长，

所以步长（fast）= 2*步长（slow） ,所以(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

而此时X表示的就是头节点到环形链表入口节点的距离，所以要求x ，将x单独放在左面：x = n (y + z) - y ,再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

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

代码随想录