这道题的关键在于:
1、在置换两个节点的时候，当前节点需要在这俩节点之前一个节点。并且要提前保存cur.next以及cur.next.next。
2、每次置换完一组节点，cur = cur.next.next
3、判断结束的标志：奇数个节点：cur.next.next != null 偶数个节点：cur.next != null 为了保证cur.next.next不会产生空指针，需要先判断next != null
4、最终返回的是虚拟节点的下一个节点，因为最初的head节点已经不在链表最前面了
具体步骤如下：

dummyNode.next = head;//对于0、1节点，需要创建一个虚拟节点.
ListNode temp1 = cur.next;
ListNode temp2 = cur.next.next.next;//并保存temp1和temp2.

①②③步骤按序进行
①cur.next = cur.next.next;
②cur.next.next = temp1;
③ temp1.next = temp2;

cur = cur.next.next;

/**
 * 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 dummyNode = new ListNode();
        dummyNode.next = head;
        ListNode cur = dummyNode;
        while(cur.next != null && cur.next.next != null){
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;
        }
        return dummyNode.next;
    }
}

这道题老是犯一个错误，就是控制fast和slow相遇的循环条件写成fast != slow，slow和fast就移动，但是要注意一点，slow和fast在初始的时候就应该分别向下移动一位和两位，以防止while进入死循环。

定义slow和fast两个快慢指针，slow每次移动一位，fast每次移动两位，直到相遇。slow和fast走过的路程分别为

fast是slow的两倍，可以得到等式，最终得到x和z、y的关系式

这个时候slow和fast在同一位置，再定义一个res节点指针指向head，res和slow指针同时一位一位向下移动，当两个指针相遇的时候，这个节点就是环形的入口。
代码如下：

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

这里寻找fast和slow相遇节点的while循环可以优化一下：

/**
 * 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) {
        if(head == null) return null;
        if(head.next == null || head.next.next == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        while(true){
        if(fast.next != null && fast.next.next != null) fast = fast.next.next;
        else return null;
        slow = slow.next;
        if(slow == fast) break;
        }
        ListNode res = head;
        while(slow != res){
            slow = slow.next;
            res = res.next;
        }
        return res;
    }
}

思路：
先计算出两条链表的长度，再将短的那一条链表的指针先移动链表长度差值个，然后再一起向下遍历直到相遇，如果没有相遇，最终都会到达null，返回停下之后的那个节点即可。

/**
 * 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 curA = headA;
       ListNode curB = headB;
       int lengthA = 0;
       int lengthB = 0;
       while(curA != null){
         curA = curA.next;
         lengthA++;
       }
       while(curB != null){
          curB = curB.next;
          lengthB++;
       }
        if(lengthA > lengthB){
            for(int i = 0;i < lengthA-lengthB;i++){
                headA = headA.next;
            } 
        }else{
            for(int i = 0;i < lengthB-lengthA;i++){
                headB = headB.next;
            } 
        }
        while(headA != null && headA != headB){
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    }
}