（Java）力扣：两两交换链表中的节点

题目：
思路：
类似于链表反转，定义三个指针，但是不同的是每次步长为2

代码：
非递归写法：

/**
 * 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) {
        //创建一个新的节点指向head
       ListNode node=new ListNode();
       node.next=head;

       ListNode curr=node;
       while(curr!=null && curr.next!=null && curr.next.next!=null){

        //定义三个指针，1，2，3
           ListNode f=curr;
           ListNode s=curr.next;
           ListNode t=s.next;

        //进行交换节点
           f.next=t;
           s.next=t.next;
           t.next=s;

        //将基准指针向后移动两步
           curr=curr.next.next;
       } 
       return node.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) {
        //终止条件：链表只剩一个节点或者没节点了，没得交换了。返回的是已经处理好的链表
        if(head==null || head.next==null ) return head;
     
        //一共三个节点:head, newHead, swapPairs(next.next)
      	//下面的任务便是交换这3个节点中的前两个节点
        ListNode newHead=head.next;
        head.next=swapPairs(newHead.next);
        newHead.next=head;

    //根据第二步：返回给上一级的是当前已经完成交换后，即处理好了的链表部分
        return newHead;
       
    }
}