判断链表是否为回文结构

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

链表

1、题目

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

2、思路

  • 方法一：使用栈

思路：从头遍历一遍链表，将链表结点依次放入栈中，则栈中的数据全部弹出的顺序就是原链表的逆序；然后再遍历链表，

  • 方法二：改原链表，需要注意边界

思路：先找到链表的中点（如果奇数长度，找到中点；如果偶数长度，找到上中点。），其 next 设置为空；然后将链表的后半部分逆序，最后使用两个指针，分别指向链表的两个头，比较它们的值是否一致。返回之前，要把后半部分的链表恢复成原来的样子。偶数长度的时候，后半部分链表逆序后，两个指针中有一个为空，就停止遍历。

3、代码

C++ 版

/*************************************************************************
	> File Name: 022.判断链表是否为回文结构.cpp
	> Author: Maureen 
	> Mail: Maureen@qq.com 
	> Created Time: 五  6/10 20:07:09 2022
 ************************************************************************/

#include <iostream>
#include <stack>
using namespace std;


class Node {
public:
    int value;
    Node *next;
    Node(int v) : value(v) {  }
};

//方法一：在原链表上进行改动
//时间复杂度O(n)，空间复杂度O(1)
bool isPalindrome(Node *head) {
    if (head == nullptr) return true;

    //1.找到中间节点
    Node *n1 = head; //慢指针
    Node *n2 = head; //快指针
    while (n2 != nullptr && n2->next != nullptr) {
        n1 = n1->next;
        n2 = n2->next->next;
    }

    //2.翻转后半部分链表
    n2 = n1->next;
    n1->next = nullptr;
    Node *next = nullptr;
    while (n2 != nullptr) {
        next = n2->next;
        n2->next = n1;
        n1 = n2;
        n2 = next;
    }

    //n1 为 右半部分链表反转后的头结点

    //3.判断左右两半部分的节点值是否相同
    Node *lhead = head;
    Node *rhead = n1;
    
    bool res = true;
    while (lhead != nullptr && rhead != nullptr) {
        if (lhead->value != rhead->value) {
            res = false;
            break;
        }
        lhead = lhead->next;
        rhead = rhead->next;
    }

    //4.翻转后的链表恢复
    n2 = n1->next;
    n1->next = nullptr;
    while (n2 != nullptr) {
        next = n2->next;
        n2->next = n1;
        n1 = n2;
        n2 = next;
    }

    return res;
}

//方法二：使用容器——栈，遍历链表，将节点放入栈中，弹栈的顺序即是原链表的逆序，如果与原链表顺序遍历一致就是回文
//额外空间复杂度: O(n)
bool isPalindrome2(Node *head) {
    stack<Node *> sta;
    Node *cur = head;
    while (cur != nullptr) {
        sta.push(cur);
        cur = cur->next;
    }

    cur = head;
    while (cur != nullptr) {
        if (cur->value != sta.top()->value) return false;
        sta.pop();
        cur = cur->next;
    }

    return true;
}


//for test 
void printLinkedList(Node *node) {
    cout << "Linked list:";
    while (node != nullptr) {
        cout << node->value << " ";
        node = node->next;
    }
    cout << endl;
}


int main() {
    //链表为空
    Node *head = nullptr;
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表： 1
    head = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表：1->1
    head = new Node(1);
    head->next = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;

    
    //链表1->2->3
    head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表1->2->1
    head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表1->2->3->1
    head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表1->2->2->1
    head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(2);
    head->next->next->next = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;


    //链表1->2->3->2->1
    head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(2);
    head->next->next->next->next = new Node(1);
    printLinkedList(head);
    cout << isPalindrome(head) << " | ";
    cout << isPalindrome2(head) << " | " << endl;
    printLinkedList(head);
    cout << "=============" << endl;

    return 0;
}

Java 版

import java.util.Stack;

public class IsPalindromeList {

	public static class Node {
		public int value;
		public Node next;

		public Node(int data) {
			this.value = data;
		}
	}

	// need n extra space
	public static boolean isPalindrome1(Node head) {
		Stack<Node> stack = new Stack<Node>();
		Node cur = head;
		while (cur != null) {
			stack.push(cur);
			cur = cur.next;
		}
		while (head != null) {
			if (head.value != stack.pop().value) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

	// need n/2 extra space
	public static boolean isPalindrome2(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Node right = head.next;
		Node cur = head;
		while (cur.next != null && cur.next.next != null) {
			right = right.next;
			cur = cur.next.next;
		}
		Stack<Node> stack = new Stack<Node>();
		while (right != null) {
			stack.push(right);
			right = right.next;
		}
		while (!stack.isEmpty()) {
			if (head.value != stack.pop().value) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

	// need O(1) extra space
	public static boolean isPalindrome3(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Node n1 = head;
		Node n2 = head;
		while (n2.next != null && n2.next.next != null) { // find mid node
			n1 = n1.next; // n1 -> mid
			n2 = n2.next.next; // n2 -> end
		}
		// n1 中点
		
		
		n2 = n1.next; // n2 -> right part first node
		n1.next = null; // mid.next -> null
		Node n3 = null;
		while (n2 != null) { // right part convert
			n3 = n2.next; // n3 -> save next node
			n2.next = n1; // next of right node convert
			n1 = n2; // n1 move
			n2 = n3; // n2 move
		}
		n3 = n1; // n3 -> save last node
		n2 = head;// n2 -> left first node
		boolean res = true;
		while (n1 != null && n2 != null) { // check palindrome
			if (n1.value != n2.value) {
				res = false;
				break;
			}
			n1 = n1.next; // left to mid
			n2 = n2.next; // right to mid
		}
		n1 = n3.next;
		n3.next = null;
		while (n1 != null) { // recover list
			n2 = n1.next;
			n1.next = n3;
			n3 = n1;
			n1 = n2;
		}
		return res;
	}

	public static void printLinkedList(Node node) {
		System.out.print("Linked List: ");
		while (node != null) {
			System.out.print(node.value + " ");
			node = node.next;
		}
		System.out.println();
	}

	public static void main(String[] args) {

		Node head = null;
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

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

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

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

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

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

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

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

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

	}
}
明朗晨光
关注
专栏目录
算法练习：判断一个链表是否为回文结构
weixin_40323516的博客
12-15 1355
给定一个单链表的头节点head，请判断该链表是否为回文结构
判断一个链表是否为回文结构【刷题记录】
qq_49641239的博客
08-22 774
一、题目描述： 给定一个链表，请判断该链表是否为回文结构。 示例1 输入：[1] 返回值：true 示例2 输入：[2,1] 返回值：false 说明：2->1 示例3 输入：[1,2,2,1] 返回值：true 说明：1->2->2->1 二、解题思路及代码： （一）利用栈的特性,利用数组存储值进行判断 因为如果链表是回文的，那么将整个链表反转后肯定还是跟原链表是一样的。所以我们就利用栈的先进后出的特性，将整个链表的节点放进栈中，然后进行出栈操作相当于链表反转的作用，再进行依
牛客-判断一个链表是否为回文结构
weixin_41803339的博客
01-02 272
题目 描述 给定一个链表，请判断该链表是否为回文结构。 回文是指该字符串正序逆序完全一致。 数据范围： 链表节点数 0≤n≤10 ，链表中每个节点的值满足 ∣val∣≤10 思路 把链表反转一下，然后用list记录反转前和反转后是不是一样，就可以判断是不是回文链表 代码 python版本： # class ListNode: # def __init__(self, x): # self.val = x # self.next = None # # 代码中的类名、方
判断链表是否为回文结构的三种方法
最新发布
2401_83010439的博客
07-21 388
stack.pop().value){ // 如果节点值不相等，说明不是回文结构。// 创建一个栈来存储后半部分链表的节点。stack.isEmpty()){ // 从栈中弹出节点并与前半部分链表进行比较。// n1指向反转后的链表的第二个节点。
判断链表是否为回文链表
qq_57027679的博客
02-03 321
import java.util.Stack; public class pro { public static void main(String[] args) {} public static class Node { //单链表 public int value; public Node next; public Node(int data) { this.value = data; } } //方法一:使用栈 public static bool.
判断一个链表是否为回文结构
qq_45797026的博客
08-21 318
题目： 给定一个链表的头节点head，请判断该链表是否为回文结构。例如：1->2->1,返回true。1->2->2->1，返回true。1->2->3，返回false。 进阶：如果链表长度为N，时间复杂度达到O(N),额外的空间复杂度达到O(1). 就直接来额外空间O(1)的方法吧： 设置两个指针，快指针一次走两步，慢指针一次走一步，快指针走完的时候，慢指针刚好打到中点 然后把后半部分逆序 然后从两边开始，每次同时走一步，看一不一样，有不一样返回false
判断单链表是否为回文
leo的博客
09-06 1064
利用栈和队列。时间复杂度O(n) 空间复杂度O(n) 思路：遍历第一遍获取单链表的长度，再遍历一遍将前半部分压入栈中，后半部分入队。最后依次出栈和出队列，如果每一次出栈和出队的字符都相等则该单链表为回文。（注意奇数的中间既不入栈也不入队） ''' 请判断一个链表是否为回文链表 输入: 1->2->2->1 输出: True ''' import sys class ...
C++数据结构与算法之判断一个链表是否为回文结构的方法
08-30
判断链表是否为回文结构的方法 判断链表是否为回文结构是数据结构与算法中的一种重要问题。链表是一种常见的数据结构形式，它可以用来存储大量的数据。但是，在实际应用中，我们经常需要判断链表是否具有回文结构，...
判断链表是否为回文链表leetcode-LeetCode:力码
07-01
判断链表是否为回文链表 leetcode LeetCode 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数 给定一个 32 位有符号整数，将整数中的数字进行反转 判断一个整数是否是回文数。回文数是指正序（从左向右...
算法题解：判断链表是否为回文链表
fe_watermelon的博客
06-10 1210
大家好，我是前端西瓜哥，今天来做一道算法题。给一个单链表，判断是否为回文链表。所谓回文，就是左右值对称相同的链表，比如 、。而像 这种则不是回文链表。 LeetCode 对应为 234 题，难度标记为简单，我不是很认可的。大概因为大家都先转换为数组，然后头尾指针往中间靠近，一一对比，那确实简单很多。但面试的时候，大概率是要求空间复杂度是 O(1) 的，即不许用数组。如果可以用数组，直接给一个数组问是否为回文数组就行了。如果不能用数组，那这题就是中等难度，它是几道题目的组合：查找链表的中间节点。对应 87
单链表练习题：判断链表是不是回文链表
nefss_的博客
07-09 282
思路：找到链表的中间节点，然后逆置后半段，再从两边比较对应位置是否值域相等。 代码： public boolean chkPalindrome(){ if(head==null){ return false; } if(head.next==null){ return true; } Node fast=head; Node cur=head; //找到中间节点 while(fast!=null&&fast.next!=null){ fast=fast.next.next; slow=s
算法-判断链表是否为回文链表
qq_23594799的博客
06-27 443
算法-判断链表是否为回文链表1、判断链表是否为回文链表 1、判断链表是否为回文链表 题目来源：Leetcode234，是一道easy题。 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/palindrome-
判断一个链表是否是一个回文结构
今天也要好好学习哟
05-30 271
【题目】 给定一个链表的头节点head，请判断该链表是否为回 文结构。 例如： 1->2->1，返回true。 1->2->2->1，返回true。 15->6->15，返回true。 1->2->3，返回false。 方式一: 遍历链表,依次把每一个节点都压入一个栈中,完成之后,栈中的节点和原来的链表的节点是逆序的 从栈中取出节点与链表的节点...
判断一个链表是否是回文链表
热门推荐
行者小朱的博客
05-26 1万+
题目描述：判断一个链表是否是回文链表（如何能达到时间复杂度为O(n)的同时空间复杂度为O(1)） 解题思路：最初的思路是遍历链表，取出其中的结点值拼成字符串，然后判断字符串是否是回文字符串，如下： boolean isPalindrome(ListNode head) { ListNode p = head; String str = ""; while(p != null){ st
【链表】判断一个链表是否是回文链表
暮色年华的博客
04-26 414
思路一：链表转为字符串，判断字符串是否是回文串 思路二：双指针 可以使用快慢指针，快指针的速度是慢指针的两倍，当快指针到达链表尾部时 ，慢指针到达中间位置。将慢指针之后的部分进行反转，再与前半部分比较 只要反转以slow.next为头结点的链表，与前面的比较即可。 public class Solution { /** * * @param head ListNode类 the head * @return bool布尔型 */ ...
算法总结之 判断一个链表是否是回文结构
art_code的博客
09-10 261
算法总结之 判断一个链表是否是回文结构 给定一个链表的头节点head，判断是否是回文结构 1->2->1 返回true 进阶： 如果链表长度N,时间复杂度O(N) 额外空间O（1） 方法一 利用栈结构（需要额外空间） 从左到右遍历，一次压栈。 这样的到的 从栈顶到栈底的节点值出现顺序会与原链表从左到右的值出现顺序...
反转整个链表判断一个链表是否为回文结构
09-07
要判断链表是否为回文结构，可以使用快慢指针的方法找到链表的中点，然后将后半部分反转。比较前半部分和反转后的后半部分是否相等，即可判断是否为回文结构。 ```python def isPalindrome(head): if not head or ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值