题目描述：

        难度：简单

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

示例 1：

输入：head = [1,2,2,1]
输出：true

示例 2：

输入：head = [1,2]
输出：false

约束：

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

解题准备：

        1.回文的概念：回文是指，倒着读和正着读一致的数、字符串或链表，比如：121，"sks"，"oopoo"

        2.链表：链表是一种线性结构，和数组类似。二者的本质区别，是链表不拘束于存储区块，其允许“任意存储”。比如：节点a存在地址1，而a的下一个节点b，存储在地址100。

        3.了解本题可能存在的基础操作：判断一个链表是否回文，必然要遍历一遍链表，所以涉及到链表的查找；；其余的目前看不出。

        4.链表的查找：由于链表的存储地址不确定，所以寻找某一个节点，只能从头节点head开始查找，对于随机出现的数，查找的时间复杂度为O（n）。

解题思路：

        由于链表是一个线性结构，其本质类似数组，不妨从数组的角度出发，思考：判断一个数组是否回文，该如何判断？

        很容易想到使用“双指针”【假设数组非null】：

        1.i指向下标0的元素，j指向下标len-1的元素。

        2.判断i、j的元素是否相等，如果不相等，返回false，否则i++、j--，如此迭代。

        3.边界考虑：如果len是偶数，会有什么情况？如果len是奇数呢？

        4.对len为偶数：此时，i、j最后一次判断，理应在i=len/2-1，j=len/2的位置。接着，i++、j--，此时i=len/2，j=len/2-1》》i>j，结束循环。

        5.对len为奇数：对此，i、j最后一次判断，是i=len/2-1，j=len/2+1。接着，i++，j--，导致i==j，于是结束循环。

        6.总结：如果i>=j，就可以结束循环，并且返回true。

        不过，由于链表不支持“随机访问”，对于某个节点node，node无法知道其上一个节点是什么，因此，数组的思路行不通。【或者可以理解为：链表没有下标关系】

        不过，链表和数组都是线性结构，很容易相互转换。

        思路1：链表转为数组

                如题，遍历一次链表，把每个节点的值存入数组，最后在数组中判断。

                这个思路问题在于：我们最初，不知道链表的长度。

                不过，既然我们只是想拿到，链表所对应数组的下标关系，完全可以采用ArrayList类辅助。

                因此，这个思路包括两步：第一步，遍历一次链表，转化为数组ArrayList；；第二步，遍历一次【只用遍历一半的元素】ArrayList，查看是否回文。

                总的迭代次数为O（n+n/2），总时间复杂度为O(n)

        思路2：用栈来辅助

                其实这个思路不如思路1简单方便，而且时间复杂度也相当，只是提供了一种新思路吧。

                第一步，遍历一次链表，拿到链表的长度len。

                第二步，将ptr指向head，再次遍历。【如果len是奇数，只用遍历len/2-1次，len是偶数，则遍历len/2次】

                遍历的同时，把数组存储进栈中。（栈可以用单调栈Deque，节省了并发处理等处理，速度非常快）

                第三步，如果len是奇数，把ptr指向ptr的下一个节点。

                第四步，继续遍历ptr，并与栈pop出的元素比较。如果不同，返回false。

                结束条件：栈为null，或者ptr为null；再或者，用for循环，遍历len/2次。

解题难点分析：

代码：

        思路1，链表转为数组：

class Solution {
    public boolean isPalindrome(ListNode head) {
        // 实例化链表对象
        List<Integer> temp = new ArrayList<Integer>();

        // 对于null的处理
        if(head==null || head.next==null){
            return true;
        }

        ListNode ptr=head;

        // 遍历一遍，并且记录所有节点值
        while(ptr!=null){
            temp.add(ptr.val);
            ptr=ptr.next;
        }

        // 记得指回头节点
        ptr=head;

        // 遍历一半节点
        for(int i=temp.size()-1; i>=temp.size()/2; i--){
            if(temp.get(i)!=ptr.val){
                return false;
            }
            ptr=ptr.next;
        }

        return true;
    }
}

        思路2，用栈辅助：

class Solution {
    public boolean isPalindrome(ListNode head) {
        // 单调栈，速度更快
        Deque<ListNode> tem=new LinkedList<>();
        int i=0; // 链表长度
        ListNode ptr=head;

        // 对null的特殊处理
        if(head==null || head.next==null){
            return true;
        }

        // 得到链表长度
        while(ptr!=null){
            i++;
            ptr=ptr.next;
        }

        // 指回头节点
        ptr=head;

        // 遍历一半，拿到前半部分节点
        for(int j=0; j<i/2; j++){
            tem.push(ptr);
            ptr=ptr.next;
        }

        // 奇数ptr指向ptr的next
        if(i%2==1){
            ptr=ptr.next;
        }

        // 判断回文否
        for(int j=0; j<i/2; j++){
            if(tem.pop().val!=ptr.val){
                return false;
            }
            ptr=ptr.next;
        }
        

        return true;
    }
}

以上内容即我想分享的关于力扣热题19的一些知识。

        我是蚊子码农，如有补充，欢迎在评论区留言。个人也是初学者，知识体系可能没有那么完善，希望各位多多指正，谢谢大家。