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

 

class Solution {
    /**
    思路: 迭代法
        pre 指针 指向 cur 指针的前一个节点
        nex 指针 指向 cur 指针的下一个节点
        tmp 指针 指向 nex 指针的下一个节点
        例如: 链表  3 -> 2 -> 5 -> 4 -> 6 -> 7 -> 8 -> 9
        此时 有可能出现的指针指向情况为
                     2 -> 3 -> 5 -> 4 -> 6 -> 7 -> 8 -> 9
                          |    |    |    |
                         pre  cur  nex  tmp

        对于外层循环, 我们保证每一次进入循环时都是这样一种初始状态
        那么接下来对于链表的操作就是
        先把 nex.next 指向 cur
                     2 -> 3 -> 5 <-> 4    6 -> 7 -> 8 -> 9
                          |    |    |    |
                         pre  cur  nex  tmp
        再把 cur.next 指向 tmp
                     2 -> 3 <-> 5 <- 4    6 -> 7 -> 8 -> 9
                          |    |    |    |
                         pre  cur  nex  tmp
        再把 pre.next 指向 nex
                     2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
                          |    |    |    |
                         pre  nex  cur  tmp
        此时, 我们就成功的把  5 -> 4 转换为 4 -> 5, 并且维持了原有链表
        但是, 当我们要进入下一次循环时, 必须把链表维持成 如下的样子
                     2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
                                    |    |    |    |
                                   pre  nex  cur  tmp
        此时我们应该
                     2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
                          |    |    |    |
                         pre  nex  cur  tmp
        先把 pre 指向当前的 cur
        再把 cur 指向当前的 tmp
        然后 cur 不为空, 就把 nex 指向 cur.next

     */

    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode H = new ListNode(0);
        H.next = head;
        ListNode pre = H;
        ListNode cur = head;
        ListNode nex = head.next;
        while (cur != null && nex != null) {
            ListNode tmp = nex.next;
            cur.next = tmp;
            nex.next = cur;
            pre.next = nex;

            pre = cur;
            cur = tmp;
            if (cur != null) {
                nex = cur.next;
            }
        }
        return H.next;
    }
}