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

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

        经过前一天的铺垫，这个24题感觉好写了很多，虽然并不知道为什么这么写就ac了.。。一开始在while循环里面没有加判断，只写了if里面的代码，测试一些正常用例的时候输出是对的，但是测试head = [1]的时候说我空指针异常，所以就想都没想加了个ifelse结果还对了。。

        我的理解是else里这段是写给奇数用的，否则在链表长度为奇数的情况下确实没有.next.next这么一说。

        首先也是在头结点前面加了个哑节点备用，循环里面大致意思是（将第一个要交换的结点称为交换1，第二个要交换的结点称为交换2）：将交换1跟交换2的连接断开，让交换1指向交换2后面的结点，再让交换2指向交换1。再让cur指向下一组要交换的交换1，重复。

/**
 * 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 dummy = new ListNode(0, head);
        ListNode cur = dummy;
        while(cur.next != null){
            ListNode temp = cur.next.next;//temp暂存交换2，防止1指向2后面结点后两条链走丢
            if(cur.next.next != null){
                cur.next.next = cur.next.next.next;
                temp.next = cur.next;
                cur.next = temp;
                cur = cur.next.next;//cur指针后移两位，移到下一组要交换的结点的交换1
            }else{//判断奇数情况
                return dummy.next;
            }
            
        }
        return dummy.next;
    }
}

        看看官解是咋写的：（没空看了先放的这儿，有空了再来看->one hundred years later）

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null && temp.next.next != null) {
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;
            temp = node1;
        }
        return dummyHead.next;
    }
}

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

        这个题我都没思考就写出来，难度中等属实有点德不配位了😓。

        一趟遍历：设两个指针，前一个指针cur一直走，后一个指针pre在cur走了n步的时候开始走，这样在cur遍历完一遍链表的时候，pre正好可以指向要删除元素的前一个元素，直接删除就行了，删除思路详见上一篇707.设计链表哈。

        别忘了哑结点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        ListNode cur = dummy;//前一个指针
        ListNode pre = dummy;//后一个指针
        //前指针先走n步
        for(int i = 0; i < n; i++){
            cur = cur.next;
        }
        while(cur.next != null){
            cur = cur.next;
            pre = pre.next;
        }
        pre.next = pre.next.next;
        return dummy.next;
    }
}

面试题 02.07. 链表相交

        我觉得这个题并不简单啊哭哭😭，想了好~~~~~半~~~~~~天~~~~~~~~~~

        我的想法是对齐两个链表，把对不齐的地方咔擦掉！人话：找到AB两个链表中较短的那个，把他们从后往前对齐，然后把长链表前面长出去的那部分截掉，这样就得到两个一样长的链表，就可以在一样长的位置上直接设置两个指针一起后移，当两个指针指到同一个结点的时候就找到啦！

        对了，这题不用哑结点，一开始哑了半天报错，去掉了就思路就清晰很多。

       

 

        当然这个方法只能说能解出来，看到题解哈希两个字的时候我就突然觉得我闭塞了，呜呜呜呜呜呜呜呜。。。。

/**
 * 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 A = headA;
        int sizeA = getListNodeSize(headA);//得到headA链表长度
        ListNode B = headB;
        int sizeB = getListNodeSize(headB);//得到headB链表长度
        int abs = Math.abs(sizeA - sizeB);
        //下面整个ifelse都是试图让AB链表指针从同一个位置对齐的操作
        if(sizeA > sizeB){
            for(int i = 0; i < abs; i++){
                A = A.next;
            }
        }else{
            for(int i = 0; i < abs; i++){
                B = B.next;
            }
        }
        //对齐之后两个指针一起后移，找到指针相等的结点就好啦
        while(A != null){
            if(A == B){
                return A;
            }
            A = A.next;
            B = B.next;
        }
        return null;
    }
    //为了得到链表长度的函数
    public int getListNodeSize(ListNode head){
        int count = 0;
        while(head != null){
            count++;
            head = head.next;
        }
        return count;
    }
}

        还有官解的双指针：（没空看了先放的这儿，有空了再来看->one hundred years later）

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

142.环形链表II

        还没看上一题题解哈希怎么做的，只知道上一题可以用哈希，这个题就来了，九敏，别的解题思路已经不重要了，我只觉得这是上天赐给我的用哈希做题的机会。

        这个题，我思路是，结点全给我进哈希表，嘤嘤嘤，要是循环了，哈希表会给出答案~

/**
 * 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) {
        HashSet<ListNode> h = new HashSet<>();
        while(head != null){
            boolean isExist = h.add(head);
            if(!isExist){
                return head;
            }
            head = head.next;
        }
        return null;
    }
}

        不出所料，执行用时：2 ms, 在所有 Java 提交中击败了19.97%的用户，呜呜呜呜呜呜呜呜

        而且很蠢的是，我一开始居然写了个==false😭

        哦我的天，刚刚看了题解，发现可以用快慢指针解决，思路是：

        快指针一次往前走两步，慢指针一次往前走一步，如果有环最终他们一定会在某个地方相遇。

        这里好像还有很多门道，但是没时间看了，有空再写这个双指针8