代码随想录算法训练营第四天 | ● 24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

 题目：24. 两两交换链表中的节点

题目链接/文章讲解/视频讲解： 代码随想录

 第一想法：当时看到这个题目的时候没有思路，直接看了题解；

看完代码随想录之后的想法：

看是看得懂，但是自己想的时候却想不出来，不知道为甚么，蓝瘦，香菇；

自己实现过程中遇到的困难 ：

看到题解后，自己实现的时候，因为要不断的更新链表，肯定遇到需要保存的节点的位置，因为可能前一个指针的指向会发生改变，，如果我们还想要使用未改变之前的前指针的下一个节点的位置，就需要先保存后节点的位置，以便后续使用，这个时候我一般新建一个指针tmp用来保存相应的节点位置；

题目：19.删除链表的倒数第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 {
     ListNode reverseList(ListNode head) {
        if(head == null)
        return head;
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
     ListNode deleteNode(ListNode head, int size, int  index) {
        if(index < 0 || index >= size)
        return head;
        ListNode demmyHead = new ListNode(0);
        demmyHead.next = head;
        ListNode cur = demmyHead;
        for(int i = 0; i < index; i++) {
            cur = cur.next;
        }
        System.out.println("1");
        cur.next =cur.next.next;
        return demmyHead.next;
    }
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode cur = head;
        int size = 0;
        while(cur != null) {
            cur = cur.next;
            size++;
        }
        ListNode ListNode1 = reverseList(head);
        ListNode ListNdoe2 = deleteNode(ListNode1, size, n - 1);
        ListNode ListNdoe3 = reverseList(ListNdoe2);
        return ListNdoe3;
    }
}

看完代码随想录之后的想法：

直接使用双指针解决就可以，fast移动n+1位之后，slow和fast一起向右移动，直到fast为null，但是我们注意到，如果删除头结点的时候，我们找不到前驱，需要特殊进行处理，因此我们直接使用虚拟节点，同时题目的n是不会超过链表的长度，因此，如果超过链表的长度的时候，我们可以先让fast移动n位，然后判断此时fast是否为空，如果为空直接返回head，如果不为空fast在移动一位然后slow和fast一起向右移动，直到fast为空；

代码如下：

/**
 * 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 dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;
        while(n >0  && fast != null) {
            fast = fast.next;
            n--;
        }
        if(fast == null)
        return head;
        fast = fast.next;
        while(fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummyHead.next;
    }
}

作者：funny-svvansonwwd
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solution/ru-guo-nda-yu-lian-biao-de-chang-du-by-f-hbr1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

自己实现过程中遇到的困难 ：

题目：面试题 02.07. 链表相交

题目链接/文章讲解：代码随想录

第一想法:想到用set，但是没有做出来

看完代码随想录之后的想法：

直接用两个指针，两个指针同时往后走，如果不相等往后走，如果一个指针为空的时候，下一次这个指针从另一个链表的开头开始，

代码如下：

/**
 * 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;
        ListNode B = headB;
        while(A != B) {
            A = A == null ? headB : A.next;
            B = B == null ? headA : B.next;
        }
    return A;
    }
}

题目：142.环形链表II 

题目链接/文章讲解/视频讲解：代码随想录

第一想法：利用哈希表实现了

看完代码随想录之后的想法：使用双指针解决