『LeetCode|每日一题』----＞两两交换链表中的节点

目录

1.每日一句

2.作者简介

 『LeetCode|每日一题』两两交换链表中的节点

1.每日一题

2.解题思路（递归）

        2.1 思路分析

        2.2 核心代码（递归）

        2.3 完整代码

        2.4 运行结果

 3.解题思路（非递归）

        3.1 思路分析

        3.2 核心代码

        3.3 完整代码

        3.4 运行结果 

---

1.每日一句

变强大不是意味着要成为一个强势的人，而是变得更加从容

2.作者简介

🏡个人主页：XiaoXiaoChen-2716 

📚学习专栏：力扣专栏 

🕒发布日期：2022/10/6

 『LeetCode|每日一题』两两交换链表中的节点

1.每日一题

原文链接--->点我

2.解题思路（递归）

        2.1 思路分析

从题中看到两两交换，就第一个想到了用递归来做，不过此题递归要注意每个节点它交换后所对应的下一个节点是哪个

        S1：首先特殊情况处理，如果是空节点或者只有一个节点，那么就直接返回这个节点，这一步在每次交换之前都得判断；

        S2：然后定义一个节点来存头节点的下一个节点，我这里是nextHead，所以此时需要交换的是head和nextHead两个节点；

        S3：假设有1，2，3，4这四个节点，刚开始交换的是1和2，但是此时我们要找到交换之后所对应的节点。比如交换之后，2的下一个节点就是1，而1的下一个节点却是4了；

        S4：所以nextHead（节点2）的下一个节点是head，也就是1。但是4这个节点怎么表示呢？此时就是递归的作用了，3和4交换之后，4就成了3和4两个节点的头节点，所以head.next就应该是递归函数（nextHead.next），也就是说，交换后1的下一个节点就对应着把3这个节点传进递归函数求出来的头节点；

        S5：最后返回nextHead这个节点，也就是新列表的头节点

        2.2 核心代码（递归）

        ListNode nextHead = head.next;
        head.next = swapPairs(nextHead.next);
        nextHead.next = head;

        2.3 完整代码

/**
 * 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;
        }
        ListNode nextHead = head.next;
        head.next = swapPairs(nextHead.next);
        nextHead.next = head;
        return nextHead;
    }
}

        2.4 运行结果

 3.解题思路（非递归）

        3.1 思路分析

如果不使用递归方法，那么就得有一个节点指向链表的头节点，以此来交换这个节点的下一个节点和下下个节点

        S1：首先定义一个节点empty用来指向链表的头节点，但是我们要保留这个节点不能被覆盖用来返回整个链表；

        S2：判断退出循环条件，如果指向头节点的节点t的下一个和下下个节点有一个为空或者都为空，那么说明交换已经做完了，不能继续交换了；

        S3：首先节点的顺序是t->t1->t2，交换完成之后节点的顺序是t->t2->t1，但是每次交换完成之后要把t指向t1，以此进行下一次交换。所以最重要的三步就是t.next = t1，t1.next = t2.next，t2.next = t1，最后t = t1即可，这样就把两个节点交换完成，并且为下一次交换做了准备；

        S4：最后所有节点交换完成，整个链表就是刚开始保留的empty节点以后的链表，所以返回empty.next就是交换之后的链表的头节点

        3.2 核心代码

        while(t.next != null && t.next.next != null){
            ListNode t1 = t.next;
            ListNode t2 = t1.next;
            t.next = t2;
            t1.next = t2.next;
            t2.next = t1;
            t = t1;
        }

        3.3 完整代码

/**
 * 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) {
        ListNode empty = new ListNode(0);   //在列表前面定义一个节点
        empty.next = head;
        ListNode t = empty;
        while(t.next != null && t.next.next != null){
            ListNode t1 = t.next;
            ListNode t2 = t1.next;
            t.next = t2;
            t1.next = t2.next;
            t2.next = t1;
            t = t1;
        }
        return empty.next;
    }
}

        3.4 运行结果

 对比递归和非递归，时间复杂度都是O(n)，但是非递归的空间复杂度是O(1)，但是递归于我而言更好理解

---

🍁 类似题目推荐：

1.数据结构基础 

2.算法专项练习 

3.剑指offer专项练习 

4.推荐一个学习网站：LeetCode，算法的提升在于日积月累，只有每天练习才能保持良好的状态

 如果文章对各位大佬有帮助就支持一下噢，新手尝试，不好的地方请各位大佬多多指教！