python回文链表_数据结构与算法 | 回文链表检测

如何判断一个单链表是否为回文链表？

回文链表

例1：

Input: 1->2

Output: false

例2：

Input: 1->2->2->1

Output: true

提升：

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

解法一

直接将链表进行 反转 ，然后将新的反转链表与原链表进行比较，这种思路最为简单粗暴。

此种解法的时间复杂度为O(n)，空间复杂度为O(n).

代码

/**

* Definition for singly-linked list.

* public class ListNode {

* int val;

* ListNode next;

* ListNode(int x) { val = x; }

* }

*/

class Solution {

public boolean isPalindrome(ListNode head) {

if(head == null){

return true;

}

ListNode newCurr = null;

ListNode newPrev = null;

ListNode curr = head;

while(curr != null){

newCurr = new ListNode(curr.val);

newCurr.next = newPrev;

newPrev = newCurr;

curr = curr.next;

}

ListNode p1 = newCurr;

ListNode p2 = head;

while(p2 != null && p2 != null){

if(p2.val != p1.val){

return false;

}

p1 = p1.next;

p2 = p2.next;

}

return true;

}

}

LeetCode性能测试：

Runtime: 3 ms, faster than 24.01% of Java online submissions forPalindrome Linked List.

解法二

为了降低空间复杂度到O(1)，我们可以只对链表的后半部分直接反转，然后将反转后的后半部分与前半部分进行比较。

如何对后半部分进行反转呢？这就涉及到我们前面的 如何找到中间节点 的方法，使用快慢指针，先找到中间节点，然后从中间节点开始反转。

需要注意的是，在进行比较时，要以后半部分为基准进行遍历来比较，例如在链表长度位偶数的情况下：

A -> B -> C -> C -> B -> A 反转得到 A -> B -> C -> C

此种解法的时间复杂度为O(n)，空间复杂度为O(1).

代码

/**

* Definition for singly-linked list.

* public class ListNode {

* int val;

* ListNode next;

* ListNode(int x) { val = x; }

* }

*/

class Solution {

public boolean isPalindrome(ListNode head) {

if(head == null){

return true;

}

// 先找到中间节点，slow最后的结果就是中间节点

ListNode slow = head;

ListNode fast = head;

for(ListNode curr = slow; slow != null; ){

if(fast == null || fast.next == null){

break;

}else{

fast = fast.next.next;

}

slow = slow.next;

}

// 从slow开始，对后链表后半部分进行反转

ListNode prev = null;

ListNode curr = slow;

ListNode next = null;

while(curr != null){

next = curr.next;

curr.next = prev;

prev = curr;

curr = next;

}

// 对前后两个部分进行比较

ListNode p1 = head;

ListNode p2 = prev;

while(p2 != null){

if(p1.val != p2.val){

return false;

}

p1 = p1.next;

p2 = p2.next;

}

return true;

}

}

LeetCode性能测试：

Runtime: 1 ms, faster than 93.05% of Java online submissions forPalindrome Linked List.

解法三

解法三比较巧妙，不容易想到。思路如下：

定义左右两个指针，左指针向有移动，"右指针向左移动"，对比左右两个指针是否配置。

我们这里是单链表，右指针怎么向左移动呢？这里通过递归的方式，当递归函数一层一层返回时，变相地实现了"右指针左移"的思路。

代码

/**

* Definition for singly-linked list.

* public class ListNode {

* int val;

* ListNode next;

* ListNode(int x) { val = x; }

* }

*/

class Solution {

private ListNode head;

private ListNode left;

public boolean isPalindrome(ListNode head1) {

head = head1;

return isPalindromeUtil(head1);

}

private boolean isPalindromeUtil(ListNode right){

left = head;

// 当指向NULL时，停止递归

if (right == null){

return true;

}

// 向右移动指针，递归调用

boolean isp = isPalindromeUtil(right.next);

if (isp == false){

return false;

}

// 比较左右指针是否匹配

boolean isp1 = (right.val == left.val);

// 移动左指针

left = left.next;

return isp1;

}

}

LeetCode性能测试：

Runtime: 3 ms, faster than 22.70% of Java online submissions forPalindrome Linked List.

相关练习

参考资料