剑指offer 专项突破版 27、回文链表

题目链接

思路：反转链表

回文的特点就是正反看都一样，那就说明是关于中点轴对称的。对于数组，我们可以从两边遍历，但是单向链表无法反向遍历，因此可以联想到如果我们用中点把链表切断，然后再把后面的链表反转，这样再同时遍历就相当于数组的反向遍历了。
注意这类需要找链表中心的题，在写前一定要想清楚快慢指针何时更新，终止条件是什么？

class Solution {

    ListNode reverseList(ListNode head) {
        ListNode pre = null, now = head;

        while (null != now) {
            ListNode next = now.next;
            now.next = pre;
            pre = now;
            now = next;
        }

        return pre;
    }

    public boolean isPalindrome(ListNode head) {

        //找出中心结点
        ListNode slow = head, fast = head;

        while (null != fast.next) {
            fast = fast.next;

            if (null != fast.next) {
                fast = fast.next;
                slow = slow.next;
            }
        }
        ListNode left = head, right = reverseList(slow.next);
        slow.next = null;

        while (null != left && null != right) {
            if (left.val != right.val) {
                break;
            }
            left = left.next;
            right = right.next;
        }

        return null == right && (null == left || null == left.next);
    }
}

Go代码

func reverseList(head *ListNode) *ListNode {
	if nil == head {
		return head
	}
	var pre *ListNode
	node := head
	for node != nil {
		next := node.Next
		node.Next = pre
		pre = node
		node = next
	}

	return pre
}

func isPalindrome(head *ListNode) bool {
	if head.Next == nil {
		return true
	}
	if head.Next.Next == nil {
		return head.Val == head.Next.Val
	}

	fast, slow := head.Next.Next, head
	for fast != nil && fast.Next != nil {
		slow = slow.Next
		fast = fast.Next.Next
	}

	tail := reverseList(slow.Next)

	for tail != nil{
		if tail.Val != head.Val{
			return false
		}
		tail = tail.Next
		head = head.Next
	}
	return true
}