算法通关村第一关——链表经典问题之回文链表

Leetcode 234. 回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

提示：

• 链表中节点数目在范围[1, 105] 内
• 0 <= Node.val <= 9

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

代码：

方法1：通过双指针的方式来判断

/**
     * 方法1：通过双指针的方式来判断
     *
     * @param head ListNode
     * @return boolean
     */
    public static boolean isPalindromeByTwoPoints(ListNode head) {
        // 边界条件判断：如果链表为空或只有一个节点，直接返回true，因为空链表和只有一个节点的链表都是回文的。
        if (head == null || head.next == null) {
            return true;
        }
        // 初始化快慢指针和前置节点：slow和fast是快慢指针，用于遍历链表。pre和prepre用于记录链表的前置节点。
        ListNode slow = head, fast = head;
        ListNode pre = head, prepre = null;
        // 快慢指针遍历链表：快指针每次走两步，慢指针每次走一步，直到快指针到达链表尾部。在此过程中，将慢指针经过的节点的前置节点记录下来，并反转链表。
        while (fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
            pre.next = prepre;
            prepre = pre;
        }
        // 处理奇数个节点的情况：如果链表的长度是奇数个，快指针会停在链表的中间节点，此时需要将慢指针向后移动一位。
        if (fast != null) {
            slow = slow.next;
        }
        // 比较前置节点和后半部分节点：从链表的前置节点开始，逐个与后半部分的节点比较值，如果不相等则返回false。
        while (pre != null && slow != null) {
            if (pre.val != slow.val) {
                return false;
            }
            pre = pre.next;
            slow = slow.next;
        }
        // 返回结果：如果所有的节点都相等，那么链表就是回文的，返回true。
        return true;
    }

方法2：全部压栈

/**
     * 方法2：全部压栈
     *
     * @param head ListNode
     * @return boolean
     */
    public static boolean isPalindromeByAllStack(ListNode head) {
        // 初始化临时节点和栈：temp用于遍历链表，stack用于存储链表的节点值。
        ListNode temp = head;
        Stack<Integer> stack = new Stack();
        // 将链表节点的值存入栈中：使用while循环，从链表头节点开始，遍历链表，将每个节点的值存入栈中。
        while (temp != null) {
            stack.push(temp.val);
            temp = temp.next;
        }
        // 比较链表节点和栈中的值：然后再遍历链表，将链表节点的值与栈中的值逐个比较，如果不相等则返回false。
        while (head != null) {
            if (head.val != stack.pop()) {
                return false;
            }
            head = head.next;
        }
        // 返回结果：如果所有的节点都相等，那么链表就是回文的，返回true。
        return true;
    }

方法3：只将一半的数据压栈

/**
     * 方法3：只将一半的数据压栈
     *
     * @param head ListNode
     * @return boolean
     */
    public static boolean isPalindromeByHalfStack(ListNode head) {
        // 边界条件判断：如果链表为空，直接返回true，因为空链表是回文的。
        if (head == null)
            return true;
        // 初始化临时节点和栈：temp用于遍历链表，stack用于存储链表的节点值。
        ListNode temp = head;
        Stack<Integer> stack = new Stack();
        // 计算链表的长度：使用while循环，从链表头节点开始，遍历链表，将每个节点的值存入栈中，并计算链表的长度。
        int len = 0;
        //把链表节点的值存放到栈中
        while (temp != null) {
            stack.push(temp.val);
            temp = temp.next;
            len++;
        }
        // 反转链表：将链表的长度除以2，得到链表中间节点的位置。
        len >>= 1;
        // 然后，将栈中的节点值逐个与链表后半部分的节点值比较，如果不相等则返回false。
        while (len-- >= 0) {
            if (head.val != stack.pop())
                return false;
            head = head.next;
        }
        // 返回结果：如果所有的节点都相等，那么链表就是回文的，返回true。
        return true;
    }

方法4：通过递归来实现

/**
     * 方法4：通过递归来实现
     *
     * @param head ListNode
     * @return boolean
     */
    public static boolean isPalindromeByRe(ListNode head) {
        // 初始化临时节点：temp用于遍历链表。
        temp = head;
        // 检查回文：调用check方法，检查链表是否是回文的。
        return check(head);
    }

    /**
     * 递归判断
     *
     * @param head ListNode
     * @return boolean
     */
    private static boolean check(ListNode head) {
        // 边界条件判断：如果链表为空，直接返回true，因为空链表是回文的。
        if (head == null)
            return true;
        // 递归判断：使用递归，判断链表的后半部分是否是回文的，并且头节点的值与后半部分的最后一个节点的值是否相等。
        boolean res = check(head.next) && (temp.val == head.val);
        // 移动临时节点：将临时节点向后移动一位。
        temp = temp.next;
        // 返回结果：根据判断结果返回相应的布尔值。
        return res;
    }

点击查看微信公众号【程序员小新儿】详细笔记