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

最新推荐文章于 2024-07-21 23:34:59 发布
最新推荐文章于 2024-07-21 23:34:59 发布
阅读量197 收藏 2
点赞数 1
分类专栏： data_struct_topic 文章标签： 单链表 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45795339/article/details/113837136
版权

题目：给定一个单链表头结点 head，请判断该链表是否为回文结构

例子：1->2->1，返回true；1->2->2->1，返回true；1->2->3，返回false。

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

分析：想到三种方法

  • 压入栈中，然后遍历同时弹栈，看节点内容是否想等

    image-20210217172004608

  • 和第一种一样不过只让链表后半部分压栈，然后遍历比对

    image-20210217171843199

  • 第三种：空间复杂度 O(1)
    step1：先用快慢指针（slow、fast）找到中点（偶数为对称轴前一个，奇数即为中点）

    step2：然后将后面的链表反转：

    ​ 1）偶数时：1 -> 2 -> 3 <- 4 <- 5 <- 6
    ​ 2）奇数时：1 -> 2 -> 3 -> 4 <- 5 <- 6 <- 7

    step3：然后分别遍历左右链表比对即可得出结果
    step4：别忘了将链表复原
    0217191654589

法一：链表全部压栈

    // 把整个链表压栈，然后遍历链表和弹栈结果是否一致
    public static boolean isPalindrome1(ListNode head) {
        if (head == null || head.next == null) return true;
        Stack<ListNode> stack = new Stack<>();
        ListNode tmp = head;
        while (tmp != null) {
            stack.push(tmp);
            tmp = tmp.next;
        }
        while (head != null && stack.pop().val == head.val) {
            head = head.next;
        }
        return head == null ? true : false;
    }

法二：一半压栈

如何找到中点：快慢指针 /slow/fast，条件如何取。有三种常见初始状态（但至少要两个节点）

  1. slow = fast = head：都指向头结点
  2. slow = head; fast = head.next; ：慢指向头结点，快指向第二节点
  3. slow = head.next; fast = head; ：慢指向第二节点，快指向头结点

然后依次讨论判断的条件是 fast.next!= null && fast.next.next != null

  •   slow = fast = head; 时
  
  EX1: 1 2	开始都指向第 1
  明显 fast 一步都不能动
  指向对称轴前一个
  
  EX2: 1 2 3 4	
  由判断条件得出fast可以走1步，那么slow指向2
  指向对称轴前一个
  
  EX3: 1 2 3 4 5 6
  fast可走2步，slow指向3
  对称轴前一个
  
  EX4: 1 2 3
  fast可以走1步，slow指向2
  指向中点位置
   
  EX5: 1 2 3 4 5
  fast可以走2步，slow指向3
  指向中点位置
  
  EX6: 1 2 3 4 5 6 7
  fast可走3步，slow指向4
  指向中点位置

  •   slow = head; fast = head.next; 时
  
  EX1:链表：1 2	slow指向1，fast指向2
  明显 fast 一步都不能动
  然后此时指向对称轴前一个
  
  EX2:链表：1 2 3 4	
  由判断条件得出fast可以走1步，那么slow指向2
  也是指向对称轴前一个
  
  EX3: 1 2 3 4 5 6
  fast可走2步，slow指向3
  对称轴前一个
  
  EX4:链表：1 2 3
  fast可以走0步，slow指向1
  指向中点前一个位置
   
  EX5:链表：1 2 3 4 5
  fast可以走1步，slow指向2
  指向中点前一个位置
  
  EX6: 1 2 3 4 5 6 7
  fast可走2步，slow指向3
  指向中点位置前一个位置

  •   slow = head.next; fast = head; 时
   
  EX1:链表：1 2	slow指向2，fast指向1
  明显 fast 一步都不能动
  然后此时指向对称轴后一个
  
  EX2:链表：1 2 3 4	
  由判断条件得出fast可以走1步，那么slow指向3
  也是指向对称轴后一个
  
  EX3: 1 2 3 4 5 6
  fast可走2步，slow指向3
  对称轴后一个
  
  EX4:链表：1 2 3
  fast可以走1步，slow指向3
  指向中点后一个位置
   
  EX5:链表：1 2 3 4 5
  fast可以走2步，slow指向4
  指向中点后一个位置
  
  EX6: 1 2 3 4 5 6 7
  fast可走3步，slow指向5
  指向中点后一个位置

最后得出结论：判断条件是 fast.next!= null && fast.next.next != null

  1. slow = fast = head;

偶数：对称轴前一个

奇数：中点

  1. slow = head; fast = head.next;

偶数：对称轴前一个

奇数：中点前一个

  1. slow = head.next; fast = head;

偶数：对称轴后一个

奇数：中点后一个

// 很容易得出，我们需要后一半压栈所以选择第三种快慢指针方案
    public static boolean isPalindrome2(ListNode head) {
        if (head == null || head.next == null) return true;
        ListNode slow = head.next;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        // 此时slow指向中点或者对称轴的下一个
        Stack<ListNode> stack = new Stack<>();
        while (slow != null) {
            stack.push(slow);
            System.out.print(slow.val + "_");
            slow = slow.next;
        }
        while (!stack.isEmpty()) {
            if (head.val != stack.pop().val) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

法三：

这里需要用到反转链表的模板，模板如下

// 加入 head 为链表的头结点
	ListNode pre = head;		// 即指向头结点
	ListNode last = head.next;	// 即指向头结点下一个
	ListNode tmp = null;
	pre.next = null;
	while (last != null) {
        tmp = last.next;
        last.next = pre;
        pre = last;
        last = tmp;
    }
// 最后循环完后的结果是 pre 指向反转的首节点，last、tmp 指向 null

    // 用偶数个举例，如链表为 1 -> 2 -> 3 -> 4 -> 5 -> 6
    public static boolean isPalindrome3(ListNode head) {
        if (head == null || head.next == null) return true;

        // step1：找到中点位置，偶数为对称轴前一个，奇数为中点
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        // step2：反转后半部分链表
        // 此时 slow 指向中点或者对称轴的前一个，也就是相当于反转部分的头结点
        // 即 slow 指向 3，接下来要反转后面部分得到：1 -> 2 -> 3 <- 4 <- 5 <- 6
        fast = slow.next;
        ListNode tmp = null;
        slow.next = null;
        while (fast != null) {
            tmp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = tmp;
        }
        tmp = slow; // 指向最后一个节点（或者后部分链表的头结点）这里后面会用到

        // step3：将两边链表分别遍历比对
        // 此时slow指向反转链表的首节点，也就是原链表的最后一个
        // 1 -> 2 -> 3 <- 4 <- 5 <- 6 slow 指向 6
        // 然后我们依次遍历两边的链表
        fast = head;
        boolean ans = true;
        while (fast != null && slow != null) {
//            System.out.print("fast:" + fast.val + ",slow:" + slow.val + "\n");
            if (fast.val != slow.val) {
                ans = false;
                break;
            }
            fast = fast.next;
            slow = slow.next;
        }

        // step4：链表复原
        // 此时 slow 指向 3，fast 指向 null
        // 如果是奇数个 slow、fast 都指向 null，所以要重新赋值
        slow = tmp;
        fast = slow.next;
        while (fast != null) {
            tmp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = tmp;
        }
        return ans;
    }

最后附上全部代码

package LinkedList;

import java.util.Stack;

/**
 * @ Date: 2021/2/10 - 13:19
 * @ Description: LinkedList
 * @ Version: 1.0
 */
// https://leetcode-cn.com/problems/palindrome-linked-list-lcci/
public class isPalindromeLinkedList_回文链表 {

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
        }
    }

    static void printLinkedList(ListNode head) {
        System.out.print("Linked List: ");
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    // 把整个链表压栈，然后遍历链表和弹栈结果是否一致
    public static boolean isPalindrome1(ListNode head) {
        if (head == null || head.next == null) return true;
        Stack<ListNode> stack = new Stack<>();
        ListNode tmp = head;
        while (tmp != null) {
            stack.push(tmp);
            tmp = tmp.next;
        }
        while (head != null && stack.pop().val == head.val) {
            head = head.next;
        }
        return head == null ? true : false;
    }

    // 半个链表压栈
    public static boolean isPalindrome2(ListNode head) {
        if (head == null || head.next == null) return true;
        ListNode slow = head.next;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        // 此时slow指向中点或者对称轴的下一个
        Stack<ListNode> stack = new Stack<>();
        while (slow != null) {
            stack.push(slow);
//            System.out.print(slow.val + "_");
            slow = slow.next;
        }
        while (!stack.isEmpty()) {
            if (head.val != stack.pop().val) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

    // 用偶数个举例，如链表为 1 -> 2 -> 3 -> 4 -> 5 -> 6
    public static boolean isPalindrome3(ListNode head) {
        if (head == null || head.next == null) return true;

        // step1：找到中点位置，偶数为对称轴前一个，奇数为中点
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        // step2：反转后半部分链表
        // 此时 slow 指向中点或者对称轴的前一个，也就是相当于反转部分的头结点
        // 即 slow 指向 3，接下来要反转后面部分得到：1 -> 2 -> 3 <- 4 <- 5 <- 6
        fast = slow.next;
        ListNode tmp = null;
        slow.next = null;
        while (fast != null) {
            tmp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = tmp;
        }
        tmp = slow; // 指向最后一个节点（或者后部分链表的头结点）这里后面会用到

        // step3：将两边链表分别遍历比对
        // 此时slow指向反转链表的首节点，也就是原链表的最后一个
        // 1 -> 2 -> 3 <- 4 <- 5 <- 6 slow 指向 6
        // 然后我们依次遍历两边的链表
        fast = head;
        boolean ans = true;
        while (fast != null && slow != null) {
//            System.out.print("fast:" + fast.val + ",slow:" + slow.val + "\n");
            if (fast.val != slow.val) {
                ans = false;
                break;
            }
            fast = fast.next;
            slow = slow.next;
        }

        // step4：链表复原
        // 此时 slow 指向 3，fast 指向 null
        // 如果是奇数个 slow、fast 都指向 null，所以要重新赋值
        slow = tmp;
        fast = slow.next;
        while (fast != null) {
            tmp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = tmp;
        }
        return ans;
    }

    public static void main(String[] args) {
        ListNode head = null;
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

        head = new ListNode(1);
        head.next = new ListNode(2);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

        head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

        head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

        head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(2);
        head.next.next.next.next = new ListNode(3);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

        head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(3);
        head.next.next.next.next.next = new ListNode(2);
        head.next.next.next.next.next.next = new ListNode(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head));

    }
}
// Output
Linked List: 
true | true | true
Linked List: 1 2 
false | false | false
Linked List: 1 2 1 
true | true | true
Linked List: 1 2 3 4 
false | false | false
Linked List: 1 2 3 2 3 
false | false | false
Linked List: 1 2 3 4 3 2 1 
true | true | true
weixin_45795339
关注
专栏目录
链表之判断一个链表是否为回文结构（一）
码莎拉蒂
01-03 1786
package com.zuo.linkedlist; import java.util.Stack; import com.zuo.linkedlist.Josephuskill2.Node; /** * 题目：给定一个头结点，判断该链表是否回文结构 * 例如： * 1->2->1 true * 1->2->2->1 true * 1->2->3 false * *思路一：
算法练习：判断一个链表是否为回文结构
weixin_40323516的博客
12-15 1375
给定一个单链表的头节点head，请判断该链表是否为回文结构
判断链表是否为回文结构的三种方法
最新发布
2401_83010439的博客
07-21 393
stack.pop().value){ // 如果节点值不相等，说明不是回文结构。// 创建一个栈来存储后半部分链表的节点。stack.isEmpty()){ // 从栈中弹出节点并与前半部分链表进行比较。// n1指向反转后的链表的第二个节点。
每日一题—— 判断一个链表是否为回文结构（快慢指针，对撞指针）
Forward♞的博客
04-13 92
由题可知：回文结构即字符串正序逆序完全一致，如“1 2 3 4 3 2 1”，那么我们就要想办法同时比较链表头和链表尾的元素，看其是否相等。最后，再将两个链表的元素逐个进行比较，只要出现不相等的情况，直接返回false，若两链表遍历完都没有出现不相等的情况，则返回true。如果链表长度length为偶数，那么翻转以mid为头节点的链表，便于与另一个链表比较。如果链表长度length为奇数，那么就翻转以mid->next为头结点的链表。首先遍历链表，求出其长度length。
牛客-判断一个链表是否为回文结构
weixin_41803339的博客
01-02 276
题目 描述 给定一个链表，请判断该链表是否为回文结构。 回文是指该字符串正序逆序完全一致。 数据范围： 链表节点数 0≤n≤10 ，链表中每个节点的值满足 ∣val∣≤10 思路 把链表反转一下，然后用list记录反转前和反转后是不是一样，就可以判断是不是回文链表 代码 python版本： # class ListNode: # def __init__(self, x): # self.val = x # self.next = None # # 代码中的类名、方
C++数据结构与算法之判断一个链表是否为回文结构的方法
01-20
本文实例讲述了C++判断一个链表是否为回文结构的方法。分享给大家供大家参考，具体如下： 题目： 给定一个链表头节点head，请判断是否为回文结构 例如： 1->2->1 true 1->2->2->1 true 1->2->3->4->2->1 false 解题...
判断一个链表是否为回文结构【刷题记录】
qq_49641239的博客
08-22 783
一、题目描述： 给定一个链表，请判断该链表是否为回文结构。 示例1 输入：[1] 返回值：true 示例2 输入：[2,1] 返回值：false 说明：2->1 示例3 输入：[1,2,2,1] 返回值：true 说明：1->2->2->1 二、解题思路及代码： （一）利用栈的特性,利用数组存储值进行判断 因为如果链表是回文的，那么将整个链表反转后肯定还是跟原链表是一样的。所以我们就利用栈的先进后出的特性，将整个链表的节点放进栈中，然后进行出栈操作相当于链表反转的作用，再进行依
判断链表是否为回文链表leetcode-LeetCode:力码
07-01
判断链表是否为回文链表 leetcode LeetCode 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数 给定一个 32 位有符号整数，将整数中的数字进行反转 判断一个整数是否是回文数。回文数是指正序（从左向右...
面试题：判断一个链表是否为回文结构
匿迹
02-06 113
面试题：判断一个链表是否为回文结构面试题：判断一个链表是否为回文结构 面试题：判断一个链表是否为回文结构 这道题，因为需要遍历链表，所以时间复杂度肯定是O(n)的。如果使用空间复杂度为O(n)是非常简单的，无非是遍历一遍链表，将节点保存到数组、List或者栈中，然后判断一次是否回文。但是如何使用常数阶的空间复杂度呢? public class NC96 { /** * 解题思路： * 这道题目可以将链表中的数值遍历一遍保存到数组中，这样判断回文串是非常的简单的，但是这样操作的空
判断某链表是否为回文结构
weixin_43718250的博客
12-14 505
题目 给定一个链表的头节点head，请判断该链表是否为回文结构。例如： 1->2->1，返回true。 1->2->2->1，返回true。 15->6->15，返回true。 1->2->3，返回false。 方案1 我们可以先弄一个栈，遍历链表将所有东西都压入到栈中，第二次遍历时，每遍历一个元素，我们就从栈中取一个元素比对，如果一样对比下一...
判断一个链表是不是回文结构
IronWring_Fly的博客
01-20 223
方法一：将整个链表入栈 import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; import java.util.Stack; class Node{ public int val; public Node next; public Node(...
判断链表是否为回文结构
肥肥很菜
01-02 171
给定一个链表的头节点 head，请判断该链表是否为回文（正反结构相同）结构。如果链表长度为 N，时间复杂度达到 O(N)，额外空间复杂度达到 O(1)。 参考：《程序员代码面试指南》 解法一 放入栈，时间复杂度O(n),空间复杂度O(n) bool isPalindrome1(Node *head) { stack&amp;amp;lt;Node&amp;amp;gt; s; Node *cur = head; ...
判断一个链表是否是一个回文结构
今天也要好好学习哟
05-30 276
【题目】 给定一个链表的头节点head，请判断该链表是否为回 文结构。 例如： 1->2->1，返回true。 1->2->2->1，返回true。 15->6->15，返回true。 1->2->3，返回false。 方式一: 遍历链表,依次把每一个节点都压入一个栈中,完成之后,栈中的节点和原来的链表的节点是逆序的 从栈中取出节点与链表的节点...
链表问题---判断一个链表是否为回文结构
冰殇的博客
11-13 983
【题目】　　给定一个链表的头节点head，请判断该链表是否为回文结构。 　　进阶：如果链表长度为N，要求时间复杂度O(N)，空间复杂度O(1)。【基本思路】　　方法一。时间复杂度O(N)，空间复杂度O(N)。 　　 　　使用栈，遍历一遍链表把每个节点都压入栈中，这样在弹出栈的时候，所有的节点就逆序了。依次对比原链表的每个节点即可。#python3.5 def isPalindrome1(hea
反转整个链表判断一个链表是否为回文结构
09-07
要判断链表是否为回文结构，可以使用快慢指针的方法找到链表的中点，然后将后半部分反转。比较前半部分和反转后的后半部分是否相等，即可判断是否为回文结构。 ```python def isPalindrome(head): if not head or ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值