链表反转的拓展问题

最新推荐文章于 2024-05-20 22:31:31 发布

张小yu

最新推荐文章于 2024-05-20 22:31:31 发布

阅读量77

点赞数

文章标签：链表数据结构算法 java

本文链接：https://blog.csdn.net/2301_79181607/article/details/132012924

版权

链表反转有两道很常见的拓展题，一个是指定区间反转，还有一个是两两交换链表中的节点，接下来我们来集中看一下。

PS：今天的内容主要是上一篇文章（反转整个链表的两种方法，一个是构建虚拟头节点，一个是直接操作）的拓展，一键直达：

终于学会链表反转了！

如果会这两种方法的可以跳过直接看下面了。

1. 指定区间反转

LeetCode92：给你单链表的头节点head和两个整数left、right，其中left <= right，请你反转从位置left到right区间的链表节点，返回反转后的链表。

图示：

实现这个操作有两种方法，一种是头插法，一种是穿针引线法（名字随意），接下来我们来看看。

1.1 头插法

头插法的思想就是：**在需要反转的区间内，每遍历到一个节点，让这个新节点来到反转区间的起始位置。**其实就是把你要反转的区间看成一个单独的链表处理，但同时又要保证和整个链表的联系不能断。如图所示：

思想上还是很好理解的，接下来看代码：

public ListNode reverseBetween(ListNode head, int left, int right) {
    // 构建一个虚拟头节点(为什么要构建，其实是考虑了反转区间的端点可能是链表头节点的情况)
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
  
    ListNode pre = dummyNode;
  
    // 找到反转区间起始端点的前一个节点
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
    
    // 遍历反转区间的节点
    ListNode cur = pre.next;
    for (int i = 0; i <= right - left; i++) {
        ListNode next = cur.next;
        cur.next = next.next;
        next.next = pre.next;
        pre.next = next;
    }
}

这个过程重要的就是每一步指针怎么指，一定要跟着代码画图，理解起来会快很多。

1.2 穿针引线法

这种方法的思路其实就是先把整个链表中要反转的区间拿出来单独做一个链表，然后反转这个链表，最后拼到原链表上去就OK了。

以反转下图中蓝色区域的链表反转为例：

先把要反转的区间反转
把pre的next指针指向反转以后的链表的头节点，反转以后的链表的尾节点的next指针指向succ

具体到代码实现上：

public ListNode reverseBetween(ListNode head, int left, int right) {
    // 构建一个虚拟头节点，避免复杂的情况讨论
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
    
    ListNode pre = dummyNode;
    
    // 找到反转区间起始节点的前一个节点
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
  
    // 找到反转区间的尾节点
    ListNode rightNode = pre;
    for (int i = 0; i < right - left; i++) {
        rightNode = rightNode.next;
    }
  
    // 把反转区间切成一个单独的链表
    ListNode leftNode = pre.next;
    ListNode succ = rightNode.next;   // 存储反转区间尾节点的后一个节点，为之后的拼接做准备
    rightNode.next = null;           // 和尾节点的后一个节点脱离关系，形成一个单独的链表
    
  	// 反转
    reverseLinkedList(leftNode);
  
    // 接回到原来的链表中
    pre.next = rightNode;
    leftNode.next = succ;
   
    return dummyNode.next;
}

private void reverseLinkedList(ListNode head) {
    // 使用不构建虚拟头节点的方式
    ListNode ans = null;
    ListNode cur = head;
  
    // 开始遍历原链表
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = ans;
        ans = cur;
        cur = next;
    }
}

2. 两两交换链表中的节点

LeetCode24：给你一个链表，两两交换相邻的节点，并返回交换后的链表的头节点（只能交换节点，不能修改节点的值达到目的）

这个问题，如果原始顺序是node1 -> node2 -> node3 -> node4，那么交换之后的顺序就变成这样了：

node2 -> node1 -> node4 -> node3

其实还是可以看成是上面那种问题的特殊情况的，只不过不需要找区间端点了，我们只要找到要反转的两个节点的前一个节点就行了。

直接上代码：

public ListNode swapPairs(ListNode head) {
    // 构建一个虚拟头节点
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
  
    // 记录反转两个节点的前一个节点
    ListNode pre = dummyNode;
  
    // 开始反转
    while (pre.next != null && pre.next.next != null) {
        ListNode node1 = pre.next;
        ListNode node2 = pre.next.next;
      
        node1.next = node2.next;
        node2.next = node1;
        pre.next = node2;
      
        pre = node1; 			// pre作为下一对反转的前一个节点
    }
  
    return dummyNode.next;
}