8. 链表 - 回文链表

1.题目

LeetCode: 234. 回文链表

【easy】

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2

输出: false

示例 2:

输入: 1->2->2->1

输出: true

进阶：

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

2.解题

方法一：栈

利用栈先进后出的特点，将链表节点放入栈中，然后遍历整个链表的同时进行出栈操作，一旦有不相等的元素则返回false，否则遍历结束后返回true。

java：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) return true;
        Stack<Integer> s = new Stack<Integer>();
        ListNode p = head;
        while (p != null) {
            s.push(p.val);
            p = p.next;
        }
        while (head != null) {
            if (head.val != s.pop()) return false;
            head = head.next;
        }
        return true;
    }
}

时间复杂度：O(n)

空间复杂度：O(n)

方法二：反转法

首先找到链表的中间节点，然后将链表的后半部分进行反转，最后比较链表前后两部分是否一致。

java：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) return true;
        ListNode fast = head, slow = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        slow = reverseList(slow.next);
        while (slow != null) {
            if (slow.val != head.val) return false;
            slow = slow.next;
            head = head.next;
        }
        return true;
    }

    // 反转链表
    public ListNode reverseList(ListNode head) {
        ListNode pre = null, cur = head;
        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)，没有使用额外的空间