2021-06-25两两交换链表中得节点

leetcode每日一题之两两交换链表中得节点

题目链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs/

题目描述：

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

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

例子：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

输入：head = []
输出：[]

输入：head = [1]
输出：[1]

**解法1：**这个题和昨天做得k个一组反转链表是一样得，无非就是把代码中得循环条件i<k改成i<2；

代码如下：

    //输入：head = [1,2,3,4]
        //输出：[2,1,4,3]
        public ListNode swapPairs(ListNode head) {
            if (head == null || head.next == null) {
                return head;
            }
            //定义一个假节点
            ListNode dummy = new ListNode(0);
            dummy.next = head;
            //定义一个节点指向交换的头节点
            ListNode pre = dummy;
            //定义 一个节点指向交换节点的尾结点
            ListNode end = dummy;
            while (end.next != null) {
                //1,2,3,4循环两次
                for (int i = 0; i < 2 && end != null; i++) {
                    end = end.next;
                }
                //首先记录end的下一个节点，方便链条的断开
                ListNode next = end.next;
                //将链条断开
                end.next = null;
                //记录pre的下一个节点也就是1
                ListNode start = pre.next;
                pre.next = reverse(start);
                //反转结束后链条就变成了dummy->2->1
                //然后将断开的链表重新链接
                start.next = next;
                pre = start;
                end = start;
            }
            return dummy.next;
        }
        //反转链表
        public ListNode reverse(ListNode head) {
            ListNode pre = null;
            ListNode cur = head;
            ListNode next = head.next;
            while (cur != null) {
                cur.next = pre;
                pre = cur;
                cur = next;
            }
            return pre;
        }

解法2：==递归！==总感觉递归特别难理解，在题解中找到了图的相关演示，可以结合着图看代码：

    public ListNode swapPairs2(ListNode head) {
            //终止条件
            if (head == null || head.next == null) {
                return head;
            }
            //假设链表是1->2->3->4
            //这句话就是先保存节点2
            ListNode newHead = head.next;
            //继续递归，处理节点3->4
            //当递归结束后，就变成了4->3
            //于是head节点就指向了4，变成1->4->3
            head.next = swapPairs(newHead.next);
            //将2节点指向1
            newHead.next = head;
            return newHead;
        }

问题求解是一样得时候也就是将大问题划分为小问题得时候想一下是否可以用递归

不要每次打开题解都是，卧槽，这也能递归，然后再分析好久。

运行过程如下图：

在这里插入图片