两两交换链表中的节点__leetcode

leetcode地址
两两交换链表中的节点
使用两种方法，迭代和递归
这是使用的节点类

 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; }

迭代

判断是否满足条件，这里的条件设置为链表的个数是否为偶数，判断方法为利用当前节点和下一节点是否都不为null，都不为null表明，本次循环为成对出现

时间复杂度：O(n)
原因分析：这里n代表的是节点数量，每次的更新操作都与节点数量有关。

空间复杂度：O(1)
原因分析：这里只是用了少数变量用于中间存储，故为O(1)。

这是代码

    public ListNode swapPairs(ListNode head) {
    	//利用哑节点
        ListNode dummyHead = new ListNode(-1);
        //利用动态节点
        ListNode prev = dummyHead;
        //这里用于判断是否为节点对
        while(head != null && head.next != null){
       		//这里使用简单的思路整理，首先prev的下一节点
       		//指向head的下一节点
       		//同时更新prev为prev的next
            prev.next = head.next;
            prev = prev.next;
            //然后继续更新prev的下一节点，这里的方法更新
            //head的下一节点为prev的next（这里原节点的关系被断开）		
            //更新prev 的next为head
            head.next = prev.next;
            prev.next = head;
            //最后更新prev和head
            prev = prev.next;
            head = head.next;
        }
        //这里判断是否当前head节点之后存在next节点
        //若成对则不会跳出while循环
        //故需要将最后的节点进行连接然后返回dummyhead的next即可
        prev.next = head == null ? null : head;
        return dummyHead.next;
    }

递归

时间复杂度：O(n)
空间复杂度：O(n)
思路还是对于中间一个小节进行考虑，剩下的内容让他们自己递归就好，这里一定要写清楚递归结束的条件，当每次交换的节点对为null或者节点对只有一个节点另一个为null时，不需要交换，迭代结束

    public ListNode swapPairs(ListNode head) {
        //迭代
        if (head == null || head.next == null)
            return head;
        //定义返回的节点
        ListNode next = head.next;
        //递归交换剩余的节点
        head.next = swapPairs(next.next);
        //返回的节点指向其前置节点
        next.next = head;
        return next;
    }