使用快慢指针，实现空间复杂度O(1)的单向链表对称性判断

需求

判断一个链表是否是回文链表

回文的形式大家应该都知道，类似

abcba 或者 abccba

这种对称的方式都是回文。

思路：
1、初始化两个指针快指针和慢指针，慢指针每次走一步，快指针每次走两步
2、依次遍历整个链表，直到快指针遍历完链表，此时fast指针已经率先到达链表的尾结点，停止遍历。因为该链表包含奇数个元素，所以slow节点需要再移动一步。指向节点2。
3、此时借助慢指针将后半部分链表反转。

反转后链表头指针为pre

4、依次遍历比较原来链表和反转后的链表pre的值是否相等，直到pre遍历到尾结点。

public class Demo1 {

    public static void main(String[] args) {
        ListNode l1 = new ListNode(1);
        ListNode l2 = new ListNode(2);
        ListNode l3 = new ListNode(3);
        ListNode l4 = new ListNode(4);
        ListNode l5 = new ListNode(3);
        ListNode l6 = new ListNode(2);
        ListNode l7 = new ListNode(1);
        l1.next = l2;
        l2.next = l3;
        l3.next = l4;
        l4.next = l5;
        l5.next = l6;
        l6.next = l7;
        //慢指针
        ListNode slow = l1;
        //快指针
        ListNode quick = l1;

        //快指针还没到尾端
        while (quick != null) {
            //慢指针走一步
            slow = slow.next;
            //快指针走两步
            quick = quick.next.next;
            if (quick.next == null || quick.next.next == null) {
                break;
            }
        }
        //慢指针走到了中间
        ListNode middle = slow;
        ListNode pre = slow;
        slow = slow.next;
        //倒置右端next
        while (slow != null) {
            ListNode tmp = slow.next;
            slow.next = pre;
            pre = slow;
            slow = tmp;
        }
        //左指针从左边开始
        ListNode left = l1;
        //右指针从尾端开始
        ListNode right = pre;
        //还没有达到中间
        while (left != middle) {
            if (left.val == right.val) {
                left = left.next;
                right = right.next;
            } else {
                System.out.println("不是对称");
                break;
            }
        }

    }

}

class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}