【单链表练习】 - 判断链表是否为回文结构

题目描述

描述
对于一个链表,请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法,判断其是否为回文结构。
给定一个链表的头指针A,请返回一个int值,代表其是否为回文结构,保证链表长度小于等于900。

示例1

输入:1->2->2->1
输出:true

解题分析:

思路1:开一个900的数组,遍历链表将数据放入数组中,记录元素个数,判断左边下标和右边下标对应的元素是否相等。数组回文结构的判断。
时间复杂度:遍历+比较 FN = N + N/2。F(N) = O(N)
空间复杂度:O(1)

思路2:查找中间结点,对相同部分的后半段进行逆置,再遍历前半段和后半段比较,判断是否相同。
注意:查找中间结点的函数。(详见这一篇文章“【单链表练习】 - 链表的中间结点”)。反转链表(链表的逆置,详见这一篇文章“【单链表练习】 - 反转单链表”)。
对于中间结点的前一个结点的next需要置空,这样方便利用前一部分循环判断与后一部分是否一致。
也可以不置空,利用后一部分循环判断与前一部分是否一致。
在这里插入图片描述
时间复杂度:逆置+找中间节点+比较 FN = N + N/2 + N/2。F(N) = O(N)
空间复杂度:O(1)

代码实现:

struct ListNode
{
    
    
	int val;
	struct ListNode* next;
};
//链表逆置 - 反转链表
struct ListNode* reverseList(struct ListNode* head)
{
    
    
	//头插法实现链表逆置
	struct ListNode* newhead = NULL;
	struct ListNode* cur = head;
	struct ListNode* next = NULL;

	//判断空链表,或则只有一个结点的链表,这里可以不需要判断,cur为NULL,不进入循环
 	if (head == NULL || head->next == NULL)
		return head;
	//迭代
	while (cur != NULL)
	{
    
    
		next = cur->next;
		//头插
		cur->next = newhead;
		newhead = cur;
		cur = next;
	}
	return newhead;
}
int chkPalindrome(struct ListNode* A)
{
    
    
	struct ListNode* fast = A;
	struct ListNode* slow = A;
	struct ListNode* prev = NULL;//保存slow的前一个,用于断掉中间结点的联系

	//第一步:找到中间结点(偶数个节点时,中间结点为第二个结点)
	while (fast && fast->next)
	{
    
    
		prev = slow;//slow走之前,保存它的地址
		slow = slow->next;
		fast = fast->next->next;
	}
	//				     prev
	//                        slow      fast
	//奇数个结点时:1 -> 2 -> 3 -> 2 -> 1 -> NULL
	//断掉中间结点的联系,即slow前一个置为NULL
	prev->next = NULL;

	//slow是中间结点指针。
	//第二步:以slow为结点的链表逆置
	//reverseList(slow);//这里虽然逆置了,但是是值传递得到的结果没有发生变化
	//3 -> 2 -> 1		逆置后1->2->3
	slow = reverseList(slow);//需要接收它的新头结点的地址

	//第三步:分解的两个链表的比较
	while(A)//A链表为空结束,因为A链表要么比slow少一个节点,要么就相等
	{
    
    
		if (A->val != slow->val)
		{
    
    
			return 0;
		}
		else
		{
    
    
			A = A->next;
			slow = slow->next;
		}
	}
	return 1;
}

优化:不断开链接
在这里插入图片描述

代码优化:

int chkPalindrome(struct ListNode* A)
{
    
    
	struct ListNode* fast = A;
	struct ListNode* slow = A;
	//第一步:找到中间结点
	while (fast && fast->next)
	{
    
    
		slow = slow->next;
		fast = fast->next->next;
	}

	//第二步:以slow为结点的链表逆置
	slow = reverseList(slow);

	//第三步:分解的两个链表的比较
	while(A && slow)//A或slow链表有一个为空,结束。实际上只需要判断slow为空则结束即可。
	{
    
    
		if (A->val != slow->val)
		{
    
    
			return 0;
		}
		else
		{
    
    
			A = A->next;
			slow = slow->next;
		}
	}
	return 1;
}

猜你喜欢

转载自blog.csdn.net/qq_48163964/article/details/130011366