Swap Nodes in Pairs 链表两两交换节点@LeetCode

题目：
链表两两交换节点

思路：
判断比较花时间，需要分奇数个节点和偶数个节点的情况，待改进。

package Level2;

import Utility.ListNode;

/**
* Swap Nodes in Pairs
*
* Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.
*
*/
public class S24 {

public static void main(String[] args) {
ListNode n1 = new ListNode(1);
ListNode n2 = new ListNode(2);
n1.next = n2;
ListNode n3 = new ListNode(3);
n2.next = n3;
n1.print();
ListNode head = swapPairs(n1);
head.print();
}

public static ListNode swapPairs(ListNode head) {
if(head == null){
return null;
}
// 当只有一个元素的情况
if(head.next == null){
return head;
}
ListNode i = head; // i指向第1个
ListNode j = i.next; // j指向第2个
ListNode k = j.next; // k指向第3个

head = head.next;
while(j != null){
j.next = i;
if(k!=null && k.next!=null){ // 当有偶数个节点
i.next = k.next;
}else{ // 当有奇数个节点
i.next = k;
}

// 更新i，j，k的值，前进两格
i = k;
if(k != null){
j = k.next;
}else{
j = null;
}
if(k!=null && k.next!=null){
k = k.next.next;
}else{
k = null;
}
}
return head;
}
}


重写：
用dummyHead解决奇偶问题，只要两个指针变量就够了
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null){
return head;
}

ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode cur = dummyHead;
ListNode probe = cur.next;
while(probe!=null && probe.next!=null){
cur.next = probe.next;
probe.next = probe.next.next;
cur.next.next = probe;
cur = probe;
probe = probe.next;
}
return dummyHead.next;
}

/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode swapPairs(ListNode head) {
if(head==null || head.next==null){
return head;
}
ListNode dm = new ListNode(0);
dm.next = head;
ListNode p=dm, q=head, r;
while(q!=null && q.next!=null){
p.next = q.next;
r = q.next.next;
p.next.next = q;
q.next = r;
p = q;
q = r;
}
return dm.next;
}
}

递归法:
public class Solution {
public ListNode swapPairs(ListNode head) {
return rec(head);
}

public ListNode rec(ListNode head) {
if(head == null || head.next == null) {
return head;
}
ListNode p = head;
ListNode q = p.next.next;
p.next.next = p;
ListNode newHead = p.next;
p.next = rec(q);
return newHead;
}
}