左神算法基础class3—题目11判断一个链表是否为回文结构（不同额外空间复杂度的三种方法）

题目：判断一个链表是否为回文结构

【题目】 给定一个链表的头节点head，请判断该链表是否为回文结构。 例如： 1->2->1，返回true。 1->2->2->1，返回true。15->6->15，返回true。 1->2->3，返回false。

进阶： 如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1)。

理解：回文结构指中间有对称轴两侧是逆序关系或者是从正方向、反方向遍历值都相同

方法一：利用堆栈结构(额外空间复杂度O(n))

思路：从正方向、反方向遍历值都相同

（1）分析

将链表按顺序存入堆栈结构中，那么栈的弹出顺序与链表的顺序刚好相反。对比栈顶元素与链表当前元素，如果不同返回false，如果相同弹出栈并把链表指向下一元素，不断遍历至空，若全部相同返回true。

（2）核心代码

①头节点初始化

注意：头节点需指向空

List MakeEmpty()
{
	List head = (List)malloc(sizeof(listnode));
	head->next = NULL;
	return head;
}

②初始化链表数据

使用尾插法，r是指向尾部的指针，找到链表末尾并加入新节点

List insert(List head,int num)
{
	//初始化新节点
	List p = (List)malloc(sizeof(listnode));
	p->val = num;
	p->next = NULL;

	//找到链表末尾
	List r = head;
	while(r->next != NULL)
	{
		r = r->next; 
	}
	//将新节点加入链表
	r->next = p;
	return head;
}

③比较栈和链表是否相同

将链表内容入栈，比较栈与链表的内容

bool IsPalindromeList(List head)
{
	List cur = head->next;//保留头节点
	stack<int> s1,s2,s_cur;
	 //把链表的内容入栈
	while(cur!= NULL)	
	{
		s1.push(cur->val);
		cur = cur->next;
	}
	//比较链表和栈的内容
	while(!s1.empty()) 	{
		if(s1.top() == head->next->val)//头节点的下一个节点是链表的第一个有效节点
		{
			s1.pop();
			head = head->next;
		}
		else
			return false;
	}
	return true;
}

（3）完整代码

#include<iostream>
#include<stack>

using namespace std;
typedef struct listnode
{
	int val ;
	listnode *next;
}*List;

bool IsPalindromeList(List head)
{
	List cur = head->next;//保留头节点
	stack<int> s1,s2,s_cur;
	while(cur!= NULL) //把链表的内容入栈
	{
		s1.push(cur->val);
		cur = cur->next;
	}
	while(!s1.empty()) //比较链表和栈的内容
	{
		if(s1.top() == head->next->val)
		{
			s1.pop();
			head = head->next;
		}
		else
			return false;
	}
	return true;
}

List insert(List head,int num)
{
	//初始化新节点
	List p = (List)malloc(sizeof(listnode));
	p->val = num;
	p->next = NULL;

	//找到链表末尾
	List r = head;
	while(r->next != NULL)
	{
		r = r->next; 
	}
	//将新节点加入链表
	r->next = p;
	return head;
}

List MakeEmpty()
{
	List head = (List)malloc(sizeof(listnode));
	head->next = NULL;
	return head;
}

int main()
{
	List head = MakeEmpty();
	insert(head,8);
	insert(head,10);
	insert(head,7);
	insert(head,10);
	insert(head,8);

	cout<<IsPalindromeList(head);
	system("pause");
	return 0;
}

方法二：利用快慢指针和堆栈结构（额外空间复杂度O(n/2)）

思路：若是回文结构，从后半部分与前半部分刚好相反。

（1）分析

使用快慢指针，快指针一次走两步，慢指针一次走一步。当快指针走完时慢指针走到一半。将慢指针的后一半入堆栈，出栈时(相当于后半部分逆序)元素如果和链表前半部分相同则是回文结构。与方法一相比，由于堆栈只存放一半元素，所以额外空间复杂度减半为n/2。
本方法的难点在于不论奇偶情况恰好让慢指针停在中间后一个的位置。
情况一：一共偶数个数
①刚开始慢指针指向第二个数，快指针指向第一个数；

②快指针走两步，慢指针走一步

③快指针走两步，慢指针走一步

④不能继续了，把慢指针指向的数依次入栈（7,10,8），再进行比较

情况二：一共奇数个数

和情况一相同，最后把10,8入栈再比较。

（2）核心代码

快慢指针

如果链表为空或者只有一个元素返回true，慢指针指向第二个数，快指针指向第一个数。在快指针能走的情况下，快指针一次走两步，慢指针一次走一步。

head = head->next;
	if (head == NULL|| head->next == NULL) 
		return true;
	List p1,p2;
	p2 = head;		//快指针
	p1 = head->next;//慢指针

	while(p2->next != NULL && p2->next->next != NULL)
	{
		p2 = p2->next->next;
		p1 = p1->next;
	}

②比较代码和方法一相同，代码复用

（3）完整代码

//使用快慢指针判断是否是回文链表
#include<iostream>
#include<stack>

using namespace std;
typedef struct listnode
{
	int val ;
	listnode *next;
}*List;

bool IsPalindromeList(List head)
{
	head = head->next;
	if (head == NULL|| head->next == NULL) 
		return true;
	List p1,p2;
	p2 = head;		//快指针
	p1 = head->next;//慢指针

	while(p2->next != NULL && p2->next->next != NULL)
	{
		p2 = p2->next->next;
		p1 = p1->next;
	}

	//链表入栈
	stack<int> s1;
	while(p1!=NULL)
	{
		s1.push(p1->val);
		p1 = p1->next ;
	}

	//对比
	while(!s1.empty())
	{
		if(head->val == s1.top())
		{
			s1.pop();
			head = head->next;
		}
		else
			return false;
	}
	return true;
}

List insert(List head,int num)
{
	//初始化新节点
	List p = (List)malloc(sizeof(listnode));
	p->val = num;
	p->next = NULL;

	//找到链表末尾
	List r = head;
	while(r->next != NULL)
	{
		r = r->next; 
	}
	//将新节点加入链表
	r->next = p;
	return head;
}

List MakeEmpty()
{
	List head = (List)malloc(sizeof(listnode));
	head->next = NULL;
	return head;
}

int main()
{
	List head = MakeEmpty();
	insert(head,8);
	insert(head,10);
	insert(head,7);
	insert(head,7);
	insert(head,10);
	insert(head,8);

	cout<<IsPalindromeList(head);
	system("pause");
	return 0;
}

方法三：利用快慢指针和逆序一半链表（额外空间复杂度O(1)）

Tips方法三实现起来比方法一、方法二复杂很多，一般只在面试过程中追求最小额外空间复杂度时使用。笔试追求稳，快用方法一和方法二。
思路：若是回文结构，后半部分逆序后与前半部分刚好相同。

（1）分析

总体分为四步，首先找到中间值，再逆序后半部分，接着进行比较，最后重排恢复链表，具体如下。
使用快慢指针，快指针一次走两步，慢指针一次走一步。当快指针走完时慢指针走到一半。方法二链表为奇数项时慢指针停在中间靠右一个位置，而方法三慢指针在正中间。从中间项开始逆序，不用辅助空间（参考反转单向和双向链表）。逆序过后，对比链表从后向前的数据和从前向后的顺序。最后，由于没有用辅助空间，链表的顺序发生了变化，需要重排链表变回原来的链表，依旧是一个逆序的过程。

本方法的难点依旧在于不论奇偶情况，奇数项停在中间，偶数项停在中间后一个位置。
与方法二不同，快慢指针最开始都在第一个数，对于奇数项的链表慢指针刚好走到中间位置，而对于偶数项的链表，先让快慢指针各走一步，之后如果快指针不能走了就结束。这样在奇数情况下快、慢指针至少走一步，只剩一个数时，慢指针依旧可以走一步，就比方法二一次走两步的情况多走了一步，慢指针最终停在中间后一个数。
情况一：一共奇数个数

情况二：一共偶数个数

上图时快指针没有到最后，快慢指针都可以继续走一步，走到下图时快指针达到最后，结束

（2）核心代码

①从头开始的快慢指针

原理如上图所示，先让快慢指针走一步再继续判断快指针是否走到最后。此处的while循环条件是快指针能不能走一步，而不是快指针能不能走两步。记录p1_pre的位置，也就是不逆序的最后一个数，最后重排时碰到p1_pre 停止。

	p2 = head;//快指针
	p1 = head;//慢指针
	while(p2->next != NULL)
	{
		p1_pre = p1;
		p2 = p2->next;
		p1 = p1->next;
		if(p2->next == NULL)
		{
			break;
		}
		p2 = p2->next;

②逆序过程

p1是中间节点的位置，从中间节点开始逆序，需要暂存当前节点、前一节点和下一节点。参考反转单向和双向链表

	List cur = p1;
	List pre = NULL;
	
	while(cur!=NULL)
	{
		List temp = cur->next;
		cur->next = pre;
		pre = cur;
		cur = temp;
	}

③比较链表首尾端是否相同

依次比较链表头端和尾端的数，如果有一位不相同res是false,退出比较，但是不能立刻返回，因为还需要重排链表，逆序过后pre是保留的最后一个数需要记录下来，重排时的开始条件就是pre

	//比较
	bool res = true;
	cur = pre;	//逆序过后pre是保留的最后一个数
	while(cur != NULL)
	{
		if(cur->val != head->val)
		{
			res = false;
			break;
		}
		cur = cur->next;
		head = head->next;
	}

④重排链表恢复如前

由逆序的最后一个数pre开始,终止条件是cur不为空且碰到未逆序的最后一个数为止

	//重排
	cur = pre;
	pre = NULL;
	while(cur!=NULL && cur!= p1_pre)
	{
		List temp = cur->next;
		cur->next = pre;
		pre = cur;
		cur = temp;
	}

（3）完整代码

//使用快慢指针但不用辅助空间判断是否是回文链表
#include<iostream>


using namespace std;
typedef struct listnode
{
	int val ;
	listnode *next;
}*List;

bool IsPalindromeList(List head)
{
	head = head->next;
	if (head == NULL|| head->next == NULL) 
		return true;
	List p1,p2,p1_pre = NULL;
	p2 = head;//快指针
	p1 = head;//慢指针

	while(p2->next != NULL)
	{
		p1_pre = p1;
		p2 = p2->next;
		p1 = p1->next;
		if(p2->next == NULL)
		{
			break;
		}
		p2 = p2->next;

	}
	//逆序
	List cur = p1;
	List pre = NULL;
	
	while(cur!=NULL)
	{
		List temp = cur->next;
		cur->next = pre;
		pre = cur;
		cur = temp;
	}

	//比较
	bool res = true;
	cur = pre;//pre是保留的最后一个数
	while(cur != NULL)
	{
		if(cur->val != head->val)
		{
			res = false;
			break;
		}
		cur = cur->next;
		head = head->next;
	}

	//重排
	cur = pre;
	pre = NULL;
	while(cur!=NULL && cur!= p1_pre)
	{
		List temp = cur->next;
		cur->next = pre;
		pre = cur;
		cur = temp;
	}

	return res;
}

List insert(List head,int num)
{
	//初始化新节点
	List p = (List)malloc(sizeof(listnode));
	p->val = num;
	p->next = NULL;

	//找到链表末尾
	List r = head;
	while(r->next != NULL)
	{
		r = r->next; 
	}
	//将新节点加入链表
	r->next = p;
	return head;
}

List MakeEmpty()
{
	List head = (List)malloc(sizeof(listnode));
	head->next = NULL;
	return head;
}

int main()
{
	List head = MakeEmpty();
	insert(head,1);
	insert(head,2);
	insert(head,3);
	insert(head,4);
	insert(head,4);
	insert(head,3);
	insert(head,2);
	insert(head,0);

	cout<<IsPalindromeList(head);
	system("pause");
	return 0;
}