Day04、链表part02

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

题目链接

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

题目描述

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

思路

这道题目正常两两交换就行。建议加个虚拟头结点可以方便后续进行同样的操作，而不用单独考虑头结点。

实现代码

/**
 * 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 tmphead = new ListNode(-1);//虚拟头结点
        tmphead.next = head;
        ListNode cur = tmphead;
        ListNode tmp = new ListNode();
        ListNode firsttmp = new ListNode();
        ListNode secondtmp = new ListNode();
        while (cur.next != null && cur.next.next != null) {
            tmp = cur.next.next.next;
            firsttmp = cur.next;//暂存第一个结点
            secondtmp = cur.next.next;//暂存第二个结点
            //进行交换
            cur.next = secondtmp;
            secondtmp.next = firsttmp;
            firsttmp.next = tmp;
            cur = firsttmp;
        }
        return tmphead.next;
    }
}

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

题目链接

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

题目描述

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

思路

这道题目容易想到的是先遍历一遍链表，得到链表的长度L，然后再进行一遍遍历到第L-n-1个的结点，第L-n个的结点就是删除的结点。
这道题想到双指针的话解的也很快。使用两个指针 first 和 second 同时对对链表进行遍历，并且 first 比 second 超前 n 个节点。当 first 遍历到链表的末尾时，second 就恰好处于倒数第 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 dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        ListNode ans = dummy.next;
        return ans;
    }

    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}

双指针

/**
 * 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 fastnode = dummyNode;
        ListNode slownode = dummyNode;

		//为了方便删除，让first 比 second 超前 n+1个节点。
        for (int i = 0; i <= n; i++){
            fastnode = fastnode.next;
        }

        while(fastnode != null){
            fastnode = fastnode.next;
            slownode = slownode.next;
        }
        slownode.next = slownode.next.next;

        return dummyNode.next;
    }
}

面试题 02.07. 链表相交

题目链接

链表相交

题目描述

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

思路

这道题配合图来理解会更快。
代码随想录-面试题 02.07. 链表相交
另一种巧妙的思路
LeetCode 160. 相交链表

142.环形链表II

题目链接

环形链表II

题目描述

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

思路

这道题主要两个点：

• 判断链表是否环
• 如果有环，如何找到这个环的入口
  对于第一点可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇，说明这个链表有环。
  对于第二点，在fast指针和slow结点相遇之后，定义两个指针，分别从相遇的点和头结点同时出发，这两个结点相遇的结点就是入口结点。
  思路的话看视频能更好的理解，这里贴上代码随想录的算法视频。

《代码随想录》算法视频公开课-LeetCode：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) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                ListNode index1 = fast;
                ListNode index2 = head;
                while (index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}