leetcode【链表—中等】24.两两交换链表中的节点

原创

长路Java 2021-10-19 15:26:35 ©著作权

文章标签 链表 leetcode 算法递归 java 文章分类 数据结构与算法人工智能

©著作权归作者所有：来自51CTO博客作者长路Java的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

前言
题目
题解
NO1：三指针移动
NO2：虚拟头节点法
NO3：递归求解
参考文章

前言

哈喽，我是长路，目前刚刚大三，方向是后端也偶尔捣鼓下前端，现在的主语言是Java。之前一大段时间都是在学习web开发的一些技术，就很久没有进行类似于数据结构、算法之类的学习与刷题，打算这段时间拾起来好好学一学、搞一搞。

这段时间也是机缘巧合看到草帽路飞的博客，加了自学群，正巧看到博主组织在群里组织了leetcode刷题打卡活动，我也就参与进来，为期一个月，打算坚持每天都花一些时间做一些题目，并通过博客的方式来进行记录。

目前跟着一个Github仓库刷题(leetcode)：代码随想录leetcode刷题，当前为链表。

题目

题目来源leetcode

leetcode地址：24. 两两交换链表中的节点，难度：简单。

题目描述(摘自leetcode)：

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

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

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

提示：
 链表中节点的数目在范围 [0, 100] 内
 0 <= Node.val <= 100

本地调试代码：

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) {
        ...
    }

public static void main(String[] args) {
ListNode node4 = new ListNode(4, null);
ListNode node3 = new ListNode(3, node4);
ListNode node2 = new ListNode(2, node3);
ListNode node1 = new ListNode(1, node2);
//两两交换犯法调用
ListNode listNode = new Solution().swapPairs(node1);
//遍历
printList(listNode);
    }

private static void printList(ListNode listNode) {
if(listNode == null){
return;
        }
System.out.print("[");
while(listNode != null){
System.out.print(listNode.val);
if(listNode.next != null){
System.out.print(",");
            }
listNode = listNode.next;
        }
System.out.print("]");
    }
}

题解

NO1：三指针移动

思路：定义三个指针，每次两两交换后，统一移动三个指针，中间可能会比较绕一点，可搭配画图进行题解。

核心其实就是不断移动三个指针，之后来进行两两交换操作，中间注意一些边界条件即可。

leetcode【链表—中等】24.两两交换链表中的节点_递归

代码：

public ListNode swapPairs(ListNode head) {
//1个或0个节点直接返回
if(head == null || head.next == null){
return head;
    }
//三个指针
ListNode preNode = null;
ListNode firstNode = head;
ListNode secNode = firstNode.next;

//最终返回的头节点
ListNode newHead = secNode;

//只有成对的才能够进行下面的操作
while(firstNode !=null && secNode != null){
//保存secNode的后一个节点
ListNode postNode = secNode.next;
//反转节点
secNode.next = firstNode;
firstNode.next = postNode;
if(preNode!=null){
preNode.next = secNode;
        }

//移动三个指针
preNode = firstNode;//第一个指针
if(postNode == null){
break;
        }
firstNode = postNode;//第二个指针
if(postNode.next == null){
break;
        }
secNode = postNode.next;
    }

return newHead;
}

leetcode【链表—中等】24.两两交换链表中的节点_算法_02

NO2：虚拟头节点法

思路：定义一个虚拟节点后，之后的操作都是相同的，其中核心是以两个指针来进行节点之间的交换。

代码：

public ListNode swapPairs(ListNode head) {
//虚拟节点
ListNode dummyNode = new ListNode(0, head);
ListNode preNode = dummyNode;
//该条件含义指的是：保证当前还有成对的进行反转。下面主要核心就是通过preNode、head两个指针来进行两两反转
while(preNode.next != null && preNode.next.next != null){
//临时保存第3个节点，之后反转链表指向第3个节点时有用
ListNode tempNode =  head.next.next;
//反转链表节点
preNode.next = head.next;
head.next.next = head;
head.next = tempNode;
//移动指针 (注意此时的head与已反转)
preNode = head;
head = preNode.next;
    }
return dummyNode.next;
}

leetcode【链表—中等】24.两两交换链表中的节点_leetcode_03

NO3：递归求解

思路：下面针对于递归题解进行部分问题解答

leetcode【链表—中等】24.两两交换链表中的节点_leetcode_04

leetcode【链表—中等】24.两两交换链表中的节点_链表_05

代码：

/**
* 递归
* @param head
* @return 上一组交换的下一个目标节点
*/
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null){
return head;
    }
ListNode next =  head.next;
ListNode newNode = swapPairs(next.next);
//反转链表，只负责当前两个节点指向
next.next = head;
head.next = newNode;
return next;
}