判断一个链表是否为回文结构【Java实现】

题目：给定一个链表的头节点head，请判断该链表是否为回文结构。

如：1 2 1 返回true

1 2 2 1 返回true

1 2 3 返回false

思路一：

利用栈，从左到右遍历链表，然后将每一个节点压入栈中。最后比较栈顶到栈底的顺序是否和链表原先的顺序一致。

代码实现：

    //判断一个链表是否为回文结构  1-2-2-1
    public static boolean isPalindrome(Node head) {
        Stack<Node> stack = new Stack<>();
        Node cur = head;
        //遍历链表
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        //比较栈顶到栈底的元素是否和链表顺序一样
        while (!stack.isEmpty()) {
            if (head.value != stack.pop().value) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

测试代码：

    public static void main(String[] args) {

        Node head = new Node(1);
        Node node1 = new Node(2);
        Node node2= new Node(2);
        Node node3 = new Node(1);

        head.next = node1;
        node1.next = node2;
        node2.next = node3;

        System.out.println(isPalindrome(head));

测试结果：

 

思路二：

只将链表的右半部分压入栈中，然后比较栈顶到栈底是否和左半部分一致。

例如 1 2 3 3 2 1

右半部分入栈，栈顶到栈底是 1 2 3，与左半部分一致的话，即有回文结构，关键是怎么找到右半部分的第一个节点。利用快慢指针，慢指针每次走一步，快指针每次走两步。

代码实现：

    //1 2 3 3 2 1 ，让右半部分 3 2 1分别入栈
    public static boolean isPalindrome2(Node head) {
        Stack<Node> stack = new Stack<>();
        //使用快慢指针
        Node slow = head;
        Node fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        //此时slow指针指的就是链表右半部分的第一个节点
        while (slow != null) {
            stack.push(slow);
            slow = slow.next;
        }
        //比较栈顶到栈底元素是否和链表左半部分相等
        while (!stack.isEmpty()) {
            if (head.value != stack.pop().value) {
                return false;
            }
            head = head.next;
        }
        return true;
    }