算法刷刷刷|链表篇|24两两交换链表中的节点|19删除链表的倒数第n个节点|链表相交|环形链表|

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = new ListNode(-1, head);
        ListNode res = pre;
        ListNode first = head;
        ListNode second = head.next;
        while (second != null) {
            ListNode tmp = second.next;
            second.next = first;
            first.next = tmp;
            pre.next = second;
            pre = first;
            first = tmp;
            if (tmp == null) {
                break;
            }
            second = tmp.next;
        }
        return res.next;
    }

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

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

public ListNode removeNthFromEnd(ListNode head, int n) {
        int len = 0;
        ListNode root = head;
        while (root != null) {
            len++;
            root = root.next;
        }
        // 需要单独判断力啊len<n和len==n的情况（[1] 1 这样root2.next.next空指针异常）
        if (len < n) {
            return head;
        }
        if (len == n) {
            return head.next;
        }
        int idx = len - n - 1;
        ListNode root2 = head;
        while (idx > 0) {
            idx--;
            root2 = root2.next;
        }
        root2.next = root2.next.next;
        return head;
    }

只遍历一次做法：快慢指针，卡哥讲解：双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了

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

面试题02 07链表相交

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

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode a = headA;
        ListNode b = headB;
        while (a != b) {
            a = a == null ? headB : a.next;
            b = b == null ? headA : b.next;
        }
        return a;
    }

如果是两个不相交的链表，在走完两个链表长度和的路程之后，a和b指向的都是Null，所以可以推出while循环并返回null。

142.环形链表

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

public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        do {
            fast = fast.next.next;
            slow = slow.next;
        } while (fast != slow && (fast != null && fast.next != null));
        if (slow == fast) {
            slow = head;
            while (slow != fast) {
                slow = slow.next;
                fast = fast.next;
            }
            return slow;
        }
        return null;
    }

快慢指针在环中某一个点相遇时，之后走到环开始节点的步数和从链表开始走到环开始节点的步数是相同的。另外要注意if (head == null || head.next == null) 返回的是null不是head，返回head的话就成一个节点的环了，注意细节。