LeetCode24. 两两交换链表中的节点（Java 代码）

题目

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

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

解题思路

跟之前的 LeetCode 25. K 个一组翻转链表（Java 版）比较相似

也需要用到LeetCode 206 反转链表 （Java 代码）中的反转链表的方法。

总而言之，当做 2个一组反转链表来做即可

代码

/*
 两两交换，就是相等于 2个一组反转链表
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        ListNode end = dummy;
        // 这里之后，建议读者画图理解
        while(end.next != null){
            for(int i=0; i<2 && end != null; i++) end = end.next;
            if(end == null){
                break;
            }
            ListNode start = prev.next;
            ListNode nextTemp = end.next;
            end.next = null;

            prev.next = reverseNode(start);

            prev = start;
            start.next = nextTemp;
            
            end = prev;
        }
        return dummy.next;
    }
	
	// 反转链表（基本操作，一定要会）
    public ListNode reverseNode(ListNode curr){
       ListNode prev = null;
       while(curr != null){
           ListNode nextTemp = curr.next;
           curr.next = prev;
           prev = curr;
           curr = nextTemp;
       }
       return prev;
    }
}

注意点

思路是正确的，但就是少些了一个东西，导致测试用例没通过

	// 让哑节点下一个指向链表头部
	dummy.next = head;

这题还可以使用递归来做，代码更少！！
题解区：传送门

引申：链表题，一定要画图，不然下面的代码就看不懂了（绕晕你）

class Solution {
    public ListNode swapPairs(ListNode head) {
        // 使用单纯的迭代实现
        ListNode curr = head, nextTemp;
        // 下面使用的解题思路，必须要画图才能想出来。。。。。。>_<
        if(curr != null && curr.next != null){
            nextTemp = curr.next;
            curr.next = nextTemp.next;
            nextTemp.next = curr;
            head = nextTemp;
            while(curr.next != null && curr.next.next != null){
            	// 这里的 curr.next.next和 curr.next 过于让人迷茫了，
            	// 下面有更好的解法
                nextTemp = curr.next.next;
                curr.next.next = nextTemp.next;
                nextTemp.next = curr.next;
                curr.next = nextTemp;

                curr = nextTemp.next;
            }
        }
        return head;
    }
}

更好的解法

非递归解法

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy= new ListNode(0);
        dummy.next = head;
        ListNode pre= dummy;
        while(pre.next != null && pre.next.next != null) {
        	// 这里的两个新建节点 start和 end有助于理解
            ListNode start = pre.next;
            ListNode end = pre.next.next;
            // 让 pre指向两个节点中的后一个（ end反转之后就是第一个）
            pre.next = end;
            // 进行反转
            start.next = end.next;
            end.next = start;
            // 此时，第一个 start反转之后就变成最后一个，此时让 pre等于它
            pre= start;
        }
        return dummy.next;
    }
}

递归解法

class Solution {
    public ListNode swapPairs(ListNode head) {
        // 只有一个或者零个节点就不反转
        if(head == null || head.next == null){
            return head;
        }
        // 保存 head节点的下一个 nextTemp
        ListNode nextTemp = head.next;
        // 更换当前节点下一个的指向
        head.next = swapPairs(nextTemp.next);
        // 此时让之前保存的 nextTemp 反过来指向 head
        nextTemp.next = head;
        // 返回现在的nextTemp
        return nextTemp;
    }
}

递归解法的思想和非递归的解法的思想是差不多的，需要多多练习就可以马上想到这种解法了。我是没想到。。。。。

最后两种解法参考自：灵魂画手