Leetcode 234. Palindrome Linked List

我的思路 :

回文链表的判断, 我的第一思路就是将其反转后再和原链表进行比较, 然后自然就想到了利用栈来实现, 但是我的这个思路满足了 O(n) 的时间复杂度但是没有满足 O(1) 的空间复杂度, 我就先实现了一下 :

 

import java.util.Stack;
class Solution {
    public boolean isPalindrome(ListNode head) {
        Stack<Integer> h = buildStack(head);
        while(head != null && !h.isEmpty()) {
            int n = head.val;
            head = head.next;
            int m = h.pop();
            if(n != m)
                return false;
        }
        return head == null ? h.isEmpty() : false;
    }
    private Stack<Integer> buildStack(ListNode l) {
        Stack<Integer> stack = new Stack<>();
        while(l != null) {
            stack.push(l.val);
            l = l.next;
        }
        return stack;
    }
}

三目比较符是个好东西, 能简化代码.

大神的思路 : 

通过两个指针, 一快一慢来找到链表的中间结点, 同时对前半部分的链表进行连接的反转, 然后从中间链表开始, 一个指针向前, 一个向后进行扫描比较.

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null)
            return true;
        ListNode fast = head;
        ListNode slow = head;
        ListNode prev = null;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            // 这里就是反转链表
            ListNode temp = slow.next;
            slow.next = prev;
            prev = slow;
            slow = temp;
        }
        // 当是奇数个结点的话, 比较的起点为中间结点的后面一个
        if(fast != null)
            slow = slow.next;
        while(prev != null) {
            if(prev.val != slow.val)
                return false;
            else {
                prev = prev.next;
                slow = slow.next;
            }
        }
        return true;
    }
}