234. 回文链表

1、题目描述

额外要求：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

2、题解

2.1 解题思路1

使用额外的栈空间，先将链表中所有的元素依次压入栈中，得到链表的逆序，然后将栈中的元素依次弹出和链表中的元素从头到尾依次比较，如果发现不相等的元素，说明该链表不是回文链表，如果直到栈空，也没发现不相等的元素，那么该链表是回文链表。

public static boolean isHuiWen01(ListNode head) {
        if (head == null) {
            return true;
        }

        Stack<Integer> stack = new Stack<>();
        ListNode cur = head;

        while (cur != null) {
            stack.push(cur.val);
            cur = cur.next;
        }

        while (!stack.isEmpty()) {
            if (stack.pop() != head.val) {
                return false;
            }
            head = head.next;
        }

        return true;
    }

这种思路，时间复杂度O(N)，空间复杂度O(N)。

2.2 解题思路2

思路2也是逆序比较的想法，通过观察可以得出，只需要将链表的后半部分元素逆序，然后和前半部分依次比较就可以得出链表是否是回文了。因此思路2和思路1的不同在于：

1. 先找到链表的中点或者下中点，然后从中点(下中点)处依次将剩下的元素压入栈中。
2. 依次弹出栈中元素和前半部分的链表元素依次比较，即可。

public static boolean isHuiWen02(ListNode head) {
        if (head == null) {
            return true;
        }

        ListNode fast = head;
        ListNode slow = head;

        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        Stack<Integer> stack = new Stack<>();
        while (slow != null) {
            stack.push(slow.val);
            slow = slow.next;
        }

        while (!stack.isEmpty()) {
            if (stack.pop() != head.val) {
                return false;
            }
            head = head.next;
        }

        return true;
    }

思路2的时间复杂度依然是O(N)，空间复杂度也是O(N)，但是系数是思路1的一半，减少了一半的栈空间。

2.3 解题思路3

思路3在思路2的基础上，去掉了栈，采用原地反转后半部分链表的思路，然后依次比较前半部分和后半部分的元素是否相等，具体来说：

1. 首先找到链表的中点或者上中点mid，如何寻找链表中点可以参考这篇文章
2. 然后将mid.next及后面的链表部分反转，同时将mid.next设置为null，这样单链表就变为了如下形式

1->2->3->4->null
1->2->null
4->3->null

3. 依次遍历两个链表，如果在遍历过程中，发现了不等元素，说明链表不是回文，否则是回文

public static boolean isHuiWen03(ListNode head) {
        if (head == null) {
            return true;
        }

        ListNode fast = head;
        ListNode slow = head;

        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        // 此时slow来到中点或者上中点的位置
        ListNode slowPre = slow;
        slow = slow.next;
        slowPre.next = null;

        slow = reverse(slow);
        ListNode cur = slow;
        while (cur != null && head != null) {
            if (cur.val != head.val) {
                return false;
            }
            cur = cur.next;
            head = head.next;
        }

        slowPre.next = reverse(slow);
        return true;
    }

    private static ListNode reverse(ListNode head) {
        ListNode next = null;
        ListNode pre = null;

        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }

        return pre;
    }

这种时间复杂度是O(N)，空间复杂度是O(1)，因为是原地反转链表

3、提交结果

下面是最后一种的提交结果，当然可以选择最后不复原链表，时间会更好一些

4、相关链接

Leetcode-回文链表题目链接
链表中点定位相关技巧博客