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

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

 交换链表中的节点，引入虚节点，判断虚节点的下一节点和下下一个节点不为空，进行链表交换包含三个步骤。第一步将虚节点的下一节点设置为虚节点的下下一个节点，然后将虚节点的下下一个节点设置为虚节点的下一个节点，然后将最开始虚节点的下一个节点的下一个节点设置成最开始的虚节点的下下一个节点。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1);
        ListNode pre = dummy;
        dummy.next = head;
        ListNode cur = dummy.next;
        ListNode temp;
        while(pre.next!=null && pre.next.next!=null){
            temp = cur.next.next;
            pre.next = cur.next;
            cur.next.next = cur;
            cur.next = temp;
            pre = pre.next.next;
            cur = temp;   
        }    
        return dummy.next;
    }
}

题目链接 19. 删除链表的倒数第 N 个结点

 使用双指针方法，首先让快指针走到第N个节点，此时同时让快慢指针向下一个节点移动，当快指针指向最后一个节点时，此时慢指针正好指向倒数第N个节点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode fastIndex = dummy;
        ListNode slowIndex = dummy;
        for(int i=0; i

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

 找出两个链表相交的节点，需要对齐两个链表的长度，接下来就很简单，只需判断两个链表中的节点是否相等

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA=0,lenB=0;
        while(curA!=null){
            lenA++;
            curA = curA.next;
        }
         while(curB!=null){
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if (lenB > lenA) {
            // 求长度差
            int subLength = lenB - lenA;
            // 让curA和curB在同一起点上（末尾位置对齐）
            while (subLength-- > 0) {
                curB = curB.next;
            }
            // 遍历curA 和 curB，遇到相同则直接返回
            while (curB != null) {
                if (curA == curB) {
                    return curB ;
                }
                curA = curA.next;
                curB = curB.next;
            }
        }else{
            int subLength = lenA - lenB;
            // 让curA和curB在同一起点上（末尾位置对齐）
            while (subLength-- > 0) {
                curA = curA.next;
            }
            // 遍历curA 和 curB，遇到相同则直接返回
            while (curA != null) {
                if (curA == curB) {
                    return curA ;
                }
                curA = curA.next;
                curB = curB.next;
            }
        } 
        return null;       
    }
}

题目链接 环形链表142. 环形链表 II 

使用快慢指针方法，先让快慢指针在环内相遇，然后让两个指针分别在头结点和相遇的节点开始移动，直到相遇，此时相遇的时候就是入环口。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {// 有环
                ListNode index1 = fast;
                ListNode index2 = head;
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index2;
            }
        }
        return null;
    }
}