（JAVA）LeetCode 234 回文链表

题目描述

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

解法一：

• 思路：遍历链表获得链表的长度，采用栈后进先出的思想，将链表的前半部分入栈，每个元素出栈判断是否与链表的元素（长度为奇数时需要向后遍历一个）相等。
• 查看LeetCode题解：也可以使用双指针法，先将链表元素置于数组中，使用双指针逐个判断是否为回文，时间复杂度和空间复杂度如该解法相同。

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null||head.next==null)
            return true;
        Stack<Integer> stack = new Stack<>();
        ListNode q = head;
        int length = ListNodeLength(q);
        for(int i=0;i<length/2;i++){
            stack.push(head.val);
            head=head.next;
        }
        if(length%2==1){
            head=head.next;
        }
        while(head!=null){
            if(head.val!=stack.pop())
                return false;
            head=head.next;
        }
        return true;
    }
    private int ListNodeLength(ListNode q){
        int length=0;
        while(q!=null){
            q=q.next;
            length++;
        }
        return length;
    }
}

• 时间复杂度：O(n) - 遍历两次链表
• 空间复杂度：O(n) - 使用栈空间存储链表元素

解法二：快慢指针

• 上图为LeetCode官网解释，感觉已经很清晰了，就直接扒过来了

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null||head.next==null)
            return true;
        // 快慢指针找到中间节点
        // 需要注意的是，当链表个数为偶数的时候，slow 指向第二个链表的开始。当链表个数为奇数的时候是，slow 指向最中间的位置。
        ListNode slow = head;
        ListNode fast = head;
        while(fast!=null&&fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
        }
        // 第二个链表倒置
        ListNode re = reverseList(slow);
        // 设置中间变量复原链表
        ListNode temp = re;
        // 前一半和后一半依次比较
        while(re!=null){
            if(re.val!=head.val)
                return false;
            re = re.next;
            head = head.next;
        }
        // 复原链表
        slow = reverseList(temp);
        return true;
    }
    private ListNode reverseList(ListNode head){
        if(head==null)
            return null;
        ListNode pre = null;
        while(head!=null){
            ListNode temp = head.next;
            head.next = pre;
            pre = head;
            head = temp; 
        }
        return pre;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(1)