力扣234题：回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为

回文链表

。如果是，返回 true ；否则，返回 false 。

示例 1：

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

示例 2：

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

提示：

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

【方法一】数组+指针

将链表中的数据存放在数组中，然后对数组从两头向中间开始进行遍历，比较遍历的两个数字是否相等，相等则为回文数，不相等则不是。

第一步：定义一个指针，用来遍历链表。

第二步：定义一个length来统计链表的程度。通过循环语句来进行遍历，这里采用while语句，只要链表不为空，则继续遍历统计。

第三步：定义一个数组，大小为链表的长度，将链表中的数据存放在数组中。

第四步：进行前后比较数组中的数据，若不相等，则不是回文链表，返回false，相等则是，返回true。

具体案例分析：

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

定义一个指针temp用来遍历数组。通过while语句可统计length的长度为4。

定义一个数组sum[4](下标从0~3），将链表中的数据存放在数组中（num[0]=1，num[1]=2，num[2]=2，num[3]=1）

利用for语句对数组的头和尾进行比较。num[0]=num[3]，num[1]=num[2]，最后返回true。

C语言具体代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool isPalindrome(struct ListNode* head) {
	struct ListNode *temp=head;
	int length=0;
	while(temp != NULL){//用来统计链表长度
		length ++;
		temp = temp->next;
	}
	int num[length];
	temp = head;
	length=0;
	while(temp!= NULL){//将链表中的数据存放在数组中
		num[length++]=temp->val;
		temp=temp->next;
	}
	for(int i=0,j=length-1;i<j;i++,j--){//比较数组的头和尾的数据，判断是否为回文
		if(num[i] != num[j]){
			return false;
		}
	}
	return true;
}

时间复杂度O(n），空间复杂度O（n）

【方法二】中间节点+反转+原链表和反转后的链表进行比较

第一步：找到链表的中间节点。利用快慢指针进行实现，慢指针走一步，快指针走两步，当快指针不能走的时候，慢指针所停的位置为中间节点

第二步：对链表的后半部分进行逆转。利用头插法进行逆转（具体分析可看作者力扣206题：反转链表）

第三步：对逆转后的后半部分链表与原来链表的前半部分进行比较，若一样，则回文，不一样则不是回文。

具体案例分析：

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

第一步：fast和slow开始都指向1，然后fast走路两步，到达第三个节点2，slow走一步到达第二个节点2。此时，fast不能继续走，slow停在第二个节点2为之间节点。

第二步：对2,2,1进行逆转。逆转后为head2=[1,2,2]

第三步：判断回文。对head2和head1进行比较，当head2遍历结束（这个过程中head2和head始终相等）则为回文。（head2=[1,2,2],head=[1,2,2,1]）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 struct ListNode * middleNode(struct ListNode * head){//利用快慢指针找中间点
 	struct ListNode *fast=head;
 	struct ListNode *slow=head;
 	while(fast!=NULL&&fast->next!=NULL){//快指针为空或者快指针的下一个节点为空时，停止走
 		fast=fast->next->next;//快指针走两次
 		slow=slow->next;//慢指针走一次
	 }
	 return slow;
 
 }
 struct ListNode * reseverNode(struct ListNode * head){//对后半部分的链表进行逆转
 	if(head == NULL){
 		return NULL;
	 }
	 struct ListNode *p=head;
    struct ListNode *q=NULL;//将头节点的next置为空
    struct ListNode *temp;
    while(p != NULL){
        temp = p->next;//用来暂存p的后继
        p->next=q;//将p的节点加入到头节点后面
        q=p;
	 	p=temp;
	 }
	 return q;
}
	 bool isPalindrome(struct ListNode * head){//判断回文数
		struct ListNode *mid=middleNode(head);//调用middleNode函数来进行找中间数mid
		struct ListNode *head2=reseverNode(mid);//从中间数开始，对后面的链表进行逆转
		while(head2 != NULL){
			if(head2->val != head->val){//判断逆转后的链表和原来的链表是不是一样
				return false;
			}
			head2 = head2->next;
			head = head->next; 
		}
		return true;
	 }
	 
 

时间复杂度O(n)，空间复杂度O(1)