力扣 - 234、回文链表

最新推荐文章于 2023-10-22 10:30:00 发布
最新推荐文章于 2023-10-22 10:30:00 发布
阅读量185 收藏 1
点赞数 2
分类专栏： # LeetCode 文章标签： 链表 数据结构 算法 leetcode c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45254369/article/details/116148234
版权

题目

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

示例 2:

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

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-linked-list

分析

数组+双指针
我们可以先遍历一遍计算出长度，然后再创建数组，再遍历一遍把节点数据放入数组中，然后在数组俩头，俩俩判断。
时间复杂度为O(n)，空间复杂度O(n)；

注：链表的头部不存储数据。所以在计算长度或者输出时，需要从head->next开始。

C

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct node LNode;
struct node
{
	int data;
	LNode* next;
};

LNode* CreateEndLinkList()//尾插法创建单链表
{
	LNode* head = NULL;
	LNode* q = NULL;
	LNode* p = NULL;

	int size = 0;

	head = (LNode*)malloc(sizeof(LNode));//申请头节点空间

	q = head;

	if (NULL == head)
	{
		perror("申请空间失败");
		exit(EXIT_FAILURE);
	}
	head->data = 0;
	head->next = NULL;

	printf("请输入需要添加的节点个数:");
	scanf("%d", &size);
	printf("请依次输入节点的值(用空格隔开):\n");
	while (size > 0)
	{
		p = (LNode*)malloc(sizeof(LNode));//申请子节点空间

		scanf("%d", &p->data);

		p->next = NULL;//尾插入
		q->next = p;
		q = p;

		size--;
	}

	return head;
}

int LengthLinkList(LNode* head)//单链表长度
{
	int len = 0;
	LNode* p = head->next;
	while (NULL != p)
	{
		len++;
		p = p->next;
	}

	return len;
}

void DelAllLinkList(LNode* head)//释放整个表  递归
{
	if (head != NULL)
	{
		DelAllLinkList(head->next);
	}

	free(head);
}

void PrintLinkList(LNode* head)//输出链表数据
{
	LNode* p = head->next;
	while (NULL != p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

//判断链表是否为回文链表   
//是回文返回true  不是回文返回false
bool isPalindrome(LNode* head)
{
	int mark = true;	//记录是否回文
	int len = LengthLinkList(head);

	int* n = (int*)malloc(sizeof(int) * len);
	int i = 0;

	LNode* p = head->next;

	while (NULL != p)//遍历链表 存入数组
	{
		n[i] = p->data;
		p = p->next;
		i++;
	}

	int start = 0;		//前指针
	int end = len - 1;	//后指针

	while (start < end)
	{
		if (n[start] != n[end])//一次不等直接跳出。
		{
			mark = false;
			break;
		}

		start++;
		end--;
	}

	return mark;
}

int main()
{
	LNode* head = CreateEndLinkList();

	bool ret = isPalindrome(head);

	if (ret == true)
	{
		printf("该链表是回文链表！\n");
	}
	else
	{
		printf("该链表不是回文链表！\n");
	}

	DelAllLinkList(head);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

快慢指针+反转链表
让快指针一次走俩步，慢指针一次走一步。当快指针停下的时候，慢指针走到中间或者中间靠右。主要是取决于节点数量为偶数和奇数。如下图
在这里插入图片描述
上图节点数为偶数
下图节点数为奇数
在这里插入图片描述
我们就可以将找中间值这段代码实现出来，如下

LNode* fast = head;//快指针
	LNode* slow = head;//慢指针
	
	/*
	* *如果是奇数列  找最中间的
	* *如果是偶数列  找左边的中间值
	*/
	while (fast->next != NULL && fast->next->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	}

接下来我们就要开始反转链表了。
在这里插入图片描述
我们发现无论是哪种情况，需要反转的链表都是从下一个节点开始。当前节点 = slow->next;
这里我们就拿偶数举例，这里我们需要三个指针前指针、当前节点指针和后指针，反转如下图。核心四步骤。(奇数也一样，读者可以自行研究)

在这里插入图片描述
在这里插入图片描述
反转后的成品图为：
在这里插入图片描述

反转代码实现如下：

LNode* front = NULL;		//前指针
	LNode* present = slow->next;//需要反转的节点  
	LNode* later = present;		//后指针
	
	
	while (present != NULL)		//反转后半部分
	{
		later = later->next;

		present->next = front;
		front = present;
		present = later;
		
	}

然后就是判断是否为回文链表，还是双指针思想，刚好从反转后的成品图中看出最后front
前指针当好指向的就是尾节点。终止条件就是后指针向前走会走到NULL。实现如下

front = head;	//前指针
	later = front;	//后指针

	/*判断回文*/
	while (later != NULL)//后指针走到空为止
	{
		if (front->data != later->data)
		{
			mark = false;
		}
		front = front->next;
		later = later->next;
	}

这时候我们的目的已经达到了。但是我们却把链表结构该修改了，所以我们还需要把链表复原。复原的思想和反转思想一样，但是前指针后后指针指向的刚好相反，在反转的时候，是后指针去探路。在复原的时候变成了前指针去探路。实现如下

/*复原链表*/
	later = NULL;	//后指针
	present = fast;	//需要反转的节点   最右边
	front = present;//前指针

	while (front != NULL)
	{
		front = front->next;

		present->next = later;
		later = present;
		present = front;
	}

然后将代码整合，
C

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct node LNode;
struct node
{
	int data;
	LNode* next;
};

LNode* CreateEndLinkList()//尾插法创建单链表
{
	LNode* head = NULL;
	LNode* q = NULL;
	LNode* p = NULL;

	int size = 0;

	head = (LNode*)malloc(sizeof(LNode));//申请头节点空间

	q = head;

	if (NULL == head)
	{
		perror("申请空间失败");
		exit(EXIT_FAILURE);
	}
	head->data = 0;
	head->next = NULL;

	printf("请输入需要添加的节点个数:");
	scanf("%d", &size);
	printf("请依次输入节点的值(用空格隔开):\n");
	while (size > 0)
	{
		p = (LNode*)malloc(sizeof(LNode));//申请子节点空间

		scanf("%d", &p->data);

		p->next = NULL;//尾插入
		q->next = p;
		q = p;

		size--;
	}

	return head;
}

int LengthLinkList(LNode* head)//单链表长度
{
	int len = 0;
	LNode* p = head->next;
	while (NULL != p)
	{
		len++;
		p = p->next;
	}

	return len;
}

void DelAllLinkList(LNode* head)//释放整个表  递归
{
	if (head != NULL)
	{
		DelAllLinkList(head->next);
	}

	free(head);
}

void PrintLinkList(LNode* head)//输出链表数据
{
	LNode* p = head->next;
	while (NULL != p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}


//判断链表是否为回文链表   
//是回文返回true  不是回文返回false
bool isPalindrome(LNode* head)
{
	bool mark = true;

	LNode* fast = head;//快指针
	LNode* slow = head;//慢指针

	/*
	* *如果是奇数列  找最中间的
	* *如果是偶数列  找左边的中间值
	*/
	while (fast->next != NULL && fast->next->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	}

	/*
	* *如果快指针的下一个不为空。就再走一步
	*/
	if (fast->next != NULL)
	{
		fast = fast->next;
	}


	LNode* front = NULL;		//前指针
	LNode* present = slow->next;//需要反转的节点  
	LNode* later = present;		//后指针


	while (present != NULL)		//反转后半部分
	{
		later = later->next;

		present->next = front;
		front = present;
		present = later;

	}

	front = head;	//前指针
	later = front;	//后指针

	/*判断回文*/
	while (later != NULL)//后指针走到空为止
	{
		if (front->data != later->data)
		{
			mark = false;
		}
		front = front->next;
		later = later->next;
	}


	/*复原链表*/
	later = NULL;	//后指针
	present = fast;	//需要反转的节点   最右边
	front = present;//前指针

	while (front != NULL)
	{
		front = front->next;

		present->next = later;
		later = present;
		present = front;
	}

	return mark;
}

int main()
{
	LNode* head = CreateEndLinkList();

	bool ret = isPalindrome(head);

	if (ret == true)
	{
		printf("该链表是回文链表！\n");
	}
	else
	{
		printf("该链表不是回文链表！\n");
	}

	DelAllLinkList(head);
	return 0;
}

该方法虽然过程繁琐，但是空间复杂度大大降低。时间复杂度为O(n),空间复杂度O(1);

递归+双指针
我们通过递归的思想让一个指针走到链表尾端，然后依次对比。实现思想较难，请读者自行画图理解。
核心代码单独列出来

LNode* front = NULL;	//前指针

//递归判断回文    
//有一次false就是false。只有都是true才是true
bool recursion(LNode* head)
{
	if (head != NULL)
	{
		if (recursion(head->next) == false)//上一次判断是false 就直接返回
		{
			return false;
		}
		if (head->data != front->data)		//当前俩节点值不相等
		{
			return false;
		}

		front = front->next;//前指针往后走
	}

	return true;
}

//判断链表是否为回文链表   
//是回文返回true  不是回文返回false
bool isPalindrome(LNode* head)
{
	front = head;

	return recursion(head);
}

总代码
C

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct node LNode;
struct node
{
	int data;
	LNode* next;
};

LNode* CreateEndLinkList()//尾插法创建单链表
{
	LNode* head = NULL;
	LNode* q = NULL;
	LNode* p = NULL;

	int size = 0;

	head = (LNode*)malloc(sizeof(LNode));//申请头节点空间

	q = head;

	if (NULL == head)
	{
		perror("申请空间失败");
		exit(EXIT_FAILURE);
	}
	head->data = 0;
	head->next = NULL;

	printf("请输入需要添加的节点个数:");
	scanf("%d", &size);
	printf("请依次输入节点的值(用空格隔开):\n");
	while (size > 0)
	{
		p = (LNode*)malloc(sizeof(LNode));//申请子节点空间

		scanf("%d", &p->data);

		p->next = NULL;//尾插入
		q->next = p;
		q = p;

		size--;
	}

	return head;
}

int LengthLinkList(LNode* head)//单链表长度
{
	int len = 0;
	LNode* p = head->next;
	while (NULL != p)
	{
		len++;
		p = p->next;
	}

	return len;
}

void DelAllLinkList(LNode* head)//释放整个表  递归
{
	if (head != NULL)
	{
		DelAllLinkList(head->next);
	}

	free(head);
}

void PrintLinkList(LNode* head)//输出链表数据
{
	LNode* p = head->next;
	while (NULL != p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

LNode* front = NULL;	//前指针

//递归判断回文    
//有一次false就是false。只有都是true才是true
bool recursion(LNode* head)
{
	if (head != front)
	{
		if (recursion(head->next) == false)//上一次判断是false 就直接返回
		{
			return false;
		}
		if (head->data != front->data)		//当前俩节点值不相等
		{
			return false;
		}

		front = front->next;//前指针往后走
	}

	return true;
}

//判断链表是否为回文链表   
//是回文返回true  不是回文返回false
bool isPalindrome(LNode* head)
{
	front = head;

	return recursion(head);
}

int main()
{
	LNode* head = CreateEndLinkList();

	bool ret = isPalindrome(head);

	if (ret == true)
	{
		printf("该链表是回文链表！\n");
	}
	else
	{
		printf("该链表不是回文链表！\n");
	}

	DelAllLinkList(head);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

本章完！

林夕07
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
234. 回文链表
01-21
判断一个链表是否为回文链表。 该题目来自力扣题库 示例 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 思路 使用栈结构，把当前链表全部压入堆栈。之后再按顺序比较链表节点以及出栈节点...
判断链表是否为回文链表leetcode-LeetCode:力扣解决方案
07-01
判断链表是否为回文链表 leetcode 力码 分而治之 划分：将问题分解为更小的子问题。 采用递归方法进行除法，直到没有子问题可以进一步除法为止。 征服：子问题被认为是自己解决的。 合并：递归地合并子问题，直到...
【LeetCode力扣】234 快慢指针 | 反转链表 | 还原链表
最新发布
Hacynn的博客
10-22 839
234. 回文链表 - 力扣（LeetCode）判断回文，就是判断是否是对称的。有些朋友对于数组的回文判断非常熟悉，但是对链表的回文判断可能就无从下手了，其实都一样的。有一种非常简单的方式就是将链表转化成数组，然后就是判断该数组是否回文就可以了，这种方式统称暴力破解法，简单粗暴。下面就来先带着大家看一下这道题的暴力破解法。
LeetCode(力扣) 234题：回文链表----三种方法求解附带详细注释
Just_do_myself的博客
08-20 925
题目描述 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。 示例 输入：head = [1,2,2,1] 输出：true 输入：head = [1,2] 输出：false 思路分析 看到这道题，相信很多朋友跟我一样，就想把链表里的元素放在列表里，然后判断列表是否为回文链表。当然这是第一种最简单直观容易想到的方法。 但是有没有其他方法？能不能像证明回文字符串那样，采用双指针的方法来解决回文链表的问题呢？答案是可以的，但是需要用到递归
力扣234题回文链表(java对撞双指针法，快慢指针法)
LNsupermali的博客
10-31 180
力扣234题回文链表(java对撞双指针法，快慢指针法)
力扣-234题 回文链表（C++）- 链表反转常规函数+双指针+有价值
qq_40467670的博客
07-14 149
题目链接：https://leetcode-cn.com/problems/palindrome-linked-list/ 题目如下： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nu
力扣234单周赛解题分享
清风Python
03-28 236
5713. 字符串中不同整数的数目 https://leetcode-cn.com/problems/number-of-different-integers-in-a-string/ 难度：简单 题目： 给你一个字符串 word ，该字符串由数字和小写英文字母组成。 请你用空格替换每个不是数字的字符。例如，"a123bc34d8ef34" 将会变成 " 123 34 8 34" 。注意，...
判断链表是否为回文链表leetcode-LeetCode:力码
07-01
判断链表是否为回文链表 leetcode LeetCode 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数 给定一个 32 位有符号整数，将整数中的数字进行反转 判断一个整数是否是回文数。回文数是指正序（从左向右...
cat0501#Java_notes#判断回文链表2
07-25
3.9 如何判断回文链表本文对应的力扣题目：234.回文链表「回文链表」问题给你输入一个单链表的头结点，请你判断这个链表中的数字是不是回文，函数签名如下：模仿双
判断链表是否为回文链表leetcode-LeetCode-Solutions:手工和STL实现的LeetCode算法任务的解决方案
07-01
判断链表是否为回文链表 leetcode 力扣 - 解决方案 我对 LeetCode 算法问题的解决方案。 目录 给定一个整数数组，返回两个数字的索引，使它们相加为特定目标。 您可以假设每个输入都只有一个解决方案，并且您不能两...
[C题目]力扣234. 回文链表
weixin_46603347的博客
07-26 161
[C题目]234.回文链表。
【力扣】234. 回文链表
漆黑梦工厂
01-29 176
题目：请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ /** * Definition for singly-linked list. * public class ListNode { * i...
力扣题234回文链表
xxyneymar的博客
12-08 374
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。 示例 1： 输入：head = [1,2,2,1] 输出：true 示例 2： 输入：head = [1,2] 输出：false 1.将链表复制到数组中，然后利用下标和头尾两个指针来对比，看是否是回文。 /** * Definition for singly-linked list. * public class ListNode { * int val;
力扣234-回文链表
南北粉面馆
08-19 170
参考网址： https://leetcode-cn.com/problems/palindrome-linked-list/solution/hui-wen-lian-biao-1zhan-2kuai-man-zhi-zhen-fan-zhu/ 使用快慢指针找到链表中间的位置，同时翻转前一部分链表，最后将翻转的链表与后半部分的链表进行比较即可。 ...
力扣234_回文链表
Yungang_Young的博客
04-22 169
题目描述： 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 算法思想： 方法一：双指针法 我们知道，判断一个数组的回文是非常简单的，只需要一头一尾两个指针，边走边检查即可，但是链表怎么办呢？ 直接暴力，把链表存入数组，用数组的方法判断。 class Solution { public boolean isPalindrome(ListNode head) { //辅助数组部
【算法题解】回文链表（力扣234题）四种方法
qq_43751336的博客
11-01 161
题目描述：回文链表1. 法一 1. 法一
力扣234. 回文链表
sinat_27523689的博客
03-03 115
请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 解题思路 先把链表转化为数组，再对数组进行判断 如果有一对不对直接返回false 只有每一对都一样的情况下才返回true /** * Definition for singly-linked list. * struc...
力扣（LeetCode）234. 回文链表
Pwnpanda的博客
05-12 412
请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 思路：寻找中间结点，然后将后半部分链表倒置，后半部分链表长度是小于或等于原链表的，所以根据后半部分链表来确定对比循环次数 #include<iostrea...
Leetcode 234:回文链表（最详细解决方案！！！）
coordinate的博客
06-18 7649
请判断一个链表是否为回文链表。 示例 1: 输入: 1-&gt;2 输出: false 示例 2: 输入: 1-&gt;2-&gt;2-&gt;1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 解题思路 我们首先想到的思路是通过建立一个list，然后将链表中的数存进去，然后判断这个list是否回文。但是这样做的空间复杂度是O(n...
力扣山的回文子串解析 代码随想录
07-27
回文子串是指正向和反向读取都相同的字符串片段。解决回文子串的问题通常有几种方法，其中一种常见的方法是使用动态规划。 以下是一种基于动态规划的解法，使用一个二维数组dp来记录子串是否为回文。 ```python ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林夕07

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值