代码随想录第四天|链表第二天

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

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

示例 1：

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

思路

这题自己想的话没有思路，主要是参考卡哥提供的代码来说说注意事项和下次碰到这个问题怎么回想起做题思路的办法

首先我们是要实现交换，那么我们最好有一个虚拟头结点，这个虚拟头结点的作用就是去完成头结点指向新的开头结点的，如果没有这一步就很难实现代码的循环进行，这题其实有点像翻转链表，但是不同的一点就是因为是交换，两两交换之后还要考虑下次的开始的结点，所以我们需要有三个指针。

1.一开始是创建了一个vir结点

2.先让当前结点指向vir，vir指向q，此时vir指向p的指针就没有了，这个时候完成了第一个正确指向

3.接下来完成第二个正确指向，要从2指向1，所以2指向3的指向消失，换成代码就是q.next = r

4.最后把末尾指向r，然后我们要进行下一次的交换，把cur指向r的前一个指针，保证每次cur都是在待交换的一对指针的前面。

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode vir = new ListNode();
        vir.next = head;
        ListNode cur = vir;
        ListNode p = head;
        while(cur.next!=null&&cur.next.next!=null){
            ListNode q = p.next;
            ListNode r = q.next;
            cur.next = q;
            q.next = p;
            p.next = r;
            cur = p; 
            p=p.next;
        }
        head = vir.next;
        return head;
    }
}

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

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

 

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

思路

这题在考研做过，第一次做的时候觉得它的处理方式是有它的妙处的，首先我们如果想找倒数第n个节点，我们就是从倒数着从1到n来找节点，如果我们需要把整个数组遍历完，我们就需要去继续走完size-n个节点，那么我们可以正着走，用正着数的程序来同步倒着数。

怎么理解我们所说的程序呢？

倒着数为n=正着数为size-n

先正着走n，那么我们剩下的节点数为size-n

故：剩下的节点数＝正着走size-n，这里就实现了正着数和倒着数的同步。

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode p = dummyNode;
        for(int i = 0;i<=n;i++){
            p = p.next;
        }
        ListNode q = dummyNode;
        while(p!=null){
            p = p.next;
            q=q.next;
        }
        q.next = q.next.next;
        return dummyNode.next;
    }
}

160.链表相交

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

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

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

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

思路

首先要注意的是它是节点指针的相等，而不是链表的值相等。

首先我想到的是先做一个对其的操作，只有相对于尾部是对齐的才能逐个比对。

但是如果想要做到尾部对齐，必须知道两个链表的长度，这个时候就需要先求长度。

求完长度之后，需要把两个链表的指针都移动到需要一一比对的起点，然后进行比对。直到将整个链表都遍历完毕，没有找到两个链表的相交结点，返回null。

代码

/**
 * 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) {
        int lenA=0,lenB = 0;
        ListNode curA = headA;
        ListNode curB = headB;
        while(curA!=null){
            lenA++;
            curA = curA.next;
        }
        while(curB!=null){
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if(lenA<lenB){//保证lenA最大
            int templ = lenA;
            lenA = lenB;
            lenB = templ;
            ListNode tempN = curA;
            curA = curB;
            curB = tempN;
        }
        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.环形链表

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fastNode = head;
        ListNode slowNode = head;
        while(fastNode!=null&&fastNode.next!=null){
            slowNode = slowNode.next;
            fastNode = fastNode.next.next;
            if(slowNode==fastNode){
                slowNode = head;
                while(slowNode !=fastNode){
                    fastNode = fastNode.next;
                    slowNode = slowNode.next;
                }
                return slowNode;
            }            
        }
        return null;
    }
}

思路

这题在之前有做过，但是只是知道他们什么时候会相遇，除此之外，我还弄错了一个入口节点和相遇节点的区别，我们的环很大可能是不在入口节点处相遇的。还有对于如何推导入口节点的判定也要仔细琢磨逻辑。

代码

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fastNode = head;
        ListNode slowNode = head;
        while(fastNode!=null&&fastNode.next!=null){
            slowNode = slowNode.next;
            fastNode = fastNode.next.next;
            if(slowNode==fastNode){
                slowNode = head;
                while(slowNode !=fastNode){
                    fastNode = fastNode.next;
                    slowNode = slowNode.next;
                }
                return slowNode;
            }            
        }
        return null;
    }
}