234.[LeetCode]Palindrome Linked List

一个要求时间复杂度是 O(n)，空间复杂度是 O(1) 的判断链表是否是回文的

// 时间和空间复杂度都有限的情况下来做运算
// 还是很简单的，遍历一遍链表，使用两个数，正向和逆向的存储我们的链表（1->1->0  =  110 和 011）。在结束后两数相减
// 特殊情况：当链表为空的时候。返回
// 以上方法是错的。妹的只考虑个位数的吗、、

// 回文数其实就是个 括号匹配的问题，可以使用栈来做，但是这样是否满足 O(1)space 的要求呢？此时应该是 O(n) soace
// 结合提示，我们可以想到，用两个 指针来在link上模拟一个栈的过程,这个模拟的过程非常有意思
// 1-2-3-4-3-2-1


// 看了答案。思路大概是：求中间节点，求后一段的反转链表，比较反转后的链表和前一段列表
// 关于技巧的东西之后讨论

public class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null) return true;

        ListNode currentNode = head;
        ListNode firstNode = head;
        ListNode secondNode = head.next;

        int size = 0;

        while(currentNode != null){
            size++;
            currentNode = currentNode.next;
        }

        int middle = size/2;

        currentNode = head;
        size = 0;
        while(currentNode != null){
            if(++size == middle) break;
            currentNode = currentNode.next;
        }

        secondNode = currentNode.next;
        secondNode = reserveList(secondNode);

        while(secondNode!=null){
            if(firstNode.val != secondNode.val) return false;
            firstNode = firstNode.next;
            secondNode = secondNode.next;
        }

        return true;
    }

    public ListNode reserveList(ListNode head){
        // 这么写是因为之前已经判断过，不可能是空串
        ListNode current = head,pre = null,n = null;
        while(current!=null){
            n = current.next;
            current.next = pre;
            pre = current;
            current = n;
        }
        return pre;
    }
}

Track：

可以通过倒转单链表实现比较

在本题中，我使用两次循环，时间复杂度为 O(1.5n)来求出中间 节点

但是其实还有更好的方法，比如使用一个快指针和一个慢指针：快指针一次移动2个，慢指针一次一个，快指针到达链尾的时候，慢指针因为就在中间

    //1, 寻找链表中间节点
    ListNode slow = head, fast = head;
    while(fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    if(fast != null)    //注意是fast!=null,而不是fast.next==null, 空指针会抛异常啊！
        slow = slow.next;   //奇数个节点,slow需要往前移动一位.(1,2,3,4,5)