高频刷题-就地反转链表(In-place Reversal of a Linked List)专题

最新推荐文章于 2023-12-03 18:23:51 发布

原创最新推荐文章于 2023-12-03 18:23:51 发布 · 364 阅读

0 ·

CC 4.0 BY-SA版权

leetcode专题专栏收录该内容

21 篇文章

订阅专栏

本文探讨了就地反转链表的模板，适用于解决链表反转问题，无需额外内存，时间复杂度为O(n)。通过迭代和递归两种方法详细解释了反转过程，并以LeetCode的《反转链表》和《回文链表》为例，介绍了如何应用这些方法。同时，提出了利用快慢指针解决《回文链表》的优化方案。

这次我们将介绍就地反转一个链表的模板，这个模板解决涉及逆转一个链表的时候非常有用，我们可以做到不使用额外的内存，在时间复杂度为O(n)的情况下完成。

该文参考如下博客:

https://emre.me/coding-patterns/in-place-reversal-of-a-linked-list/

我们直接看这个题目:

https://leetcode.com/problems/reverse-linked-list/

首先我们介绍iteration方法，这是一种遍历整个链表结构的方法。

我们初始化一个curr指针指向head，然后一个prev指针初始化为null，表示curr节点的前一个节点。

每一次我们反转curr和prev节点，也就是把curr.next指向prev，在这之前需要移动curr到下一个节点（所以需要next指针保存以前链表的curr的下一个节点），prev节点也移动到现在的curr节点的位置。

循环遍历直到curr为null，返回prev为head节点。反转完成。

图示和动画如下:

动画如下：https://cdn.emre.me/2019-11-04-in-place-reversal.gif

对应代码如下：

// 反转链表
    public ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;  // 反转之后的头指针 
    }

介绍recursive方法。

1) 把链表分成两部分 - head节点和剩下的链表部分.

2) 对剩下的部分递归调用reverse()

3) 把已经反转好的部分和head节点链接起来

4) 返回新的头节点

图示如下:

对应代码如下:

public ListNode reverseList(ListNode head) {
        // 处理链表为空，或者只有一个节点的情况
        if (head == null || head.next == null) return head;
        
        // 递归反转剩余链表，返回剩余链表的头节点newHead
        ListNode newHead = reverseList(head.next);
        
        // 将head节点和已反转好的剩余链表的头节点连接起来
        head.next.next = head;
        head.next = null;
        
        // 返回新的链表的头节点，也就是newHead
        return newHead;
    }

https://leetcode.com/problems/palindrome-linked-list/

这道题第一种解法就是把链表反转，得到新链表，然后计算新链表的数字。例如，1 2 2 1最初的数字计算是1221，反转后，计算出来也是1221。两个int类型的数字相等，那么就返回true，否则不是回文，直接返回false。

public boolean isPalindrome(ListNode head) {
        // 反转之后的数字和之前的一样，就是palindrome        
        
        int number1 = totalNumber(head);
        
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        head = prev;  // 反转之后的头指针
        
        int number2 = totalNumber(head);
        
        return number1 == number2;
    }
    
    // 链表的数字和
    private int totalNumber(ListNode head) {
        int res = 0;
        ListNode curr = head;
        
        while (curr != null) {
            res = (res * 10) + curr.val;
            curr = curr.next;
        }
        return res;
    }

还有第二种方法。观察到回文就是中心对称的结构。那么我们实际上不需要遍历整个链表，只需要使用快慢指针的方法，fast指针一次走两步，slow指针一次走一步。这样fast走到链表尾时，slow正好在中间。此时反转后面半截链表。这样反转后，就可以接着一步步走，对比每个节点。如果有一个不同，可以直接返回false。全部相同，就表示为回文。

代码如下：

public boolean isPalindrome(ListNode head) {
        ListNode fast = head, slow = head;
        while(fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        
        ListNode half = reverse(slow);
        fast = head;
        
        while (half != null) {
            if (half.val != fast.val) return false;
            half = half.next;
            fast = fast.next;
        }
        return true;
    }
    
    // 反转链表
    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;  // 反转之后的头指针 
}

此外还有如下题目，以前都已经解决过，这里就不再详述了。

https://leetcode.com/problems/reverse-linked-list-ii/

https://leetcode.com/problems/reverse-nodes-in-k-group/