leetcode刷题之回文链表

分手后的思念是犯贱 2023-09-25 17:04 115阅读 0赞

目录

做题思路

代码实现

1.找到链表的中间节点

2.反转中间节点之后的链表

3.判断倒置的后半部分的链表是否等于前半部分的链表

整体代码展示

总结:


这里是题目链接。234. 回文链表 - 力扣(Leetcode)

016357029ee94ebaa7f08ca16c30a4e0.png

这道题目的意思是:判断该链表中后半部分倒置是否跟前半部分相同,如果相同就返回true,否则就返回false。

做题思路

1.先用快慢指针来找到该链表的中间节点。

2.倒置后半部分的链表。

3.判断倒置的部分是否跟前半部分相同。

a4b55ccc89124041abf50bd37e5b9d21.png

a34e12674413428784dd488d216d0fa3.png

a2a9baa2058d4f65a5da74de358cb0aa.png

代码实现

1.找到链表的中间节点

使用一个慢指针slow,一次走一步,一个快指针fast,一次走两步。当快指针fast为null或者走到尾节点时,slow所在的节点就是该链表的中间节点。

  1. /**
  2. * Definition for singly-linked list.
  3. * public class ListNode {
  4. * int val;
  5. * ListNode next;
  6. * ListNode() {}
  7. * ListNode(int val) { this.val = val; }
  8. * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  9. * }
  10. */
  11. class solution{
  12. public boolean isPalindrome(ListNode head) {
  13. if(head == null) {
  14. return false; //判断head是否为空
  15. }
  16. ListNode slow = head;
  17. ListNode fast = head;
  18. while(fast != null && fast.next != null) {
  19. slow = slow.next;
  20. fast = fast.next.next;
  21. }
  22. //此时的slow就是链表的中间节点

我们在找到了中间节点后,接下来需要做的就是反转中间节点以后的链表

2.反转中间节点之后的链表

53629c63dc684eb286aebcfaa1cf9901.png

ce42d49f9a0342e493e3a4f20e625668.png

435768adc9d549e68879d814b9d1da47.png

  1. ListNode cur = slow.next;
  2. while(cur != null) {
  3. ListNode nextNode = cur.next; //nextNode用来记录cur的下一个节点
  4. cur.next = slow; //将cur指向cur的前一个节点
  5. slow = cur;
  6. cur = nextNode;
  7. }
  8. //此时slow的位置就是在链表的尾节点处

3.判断倒置的后半部分的链表是否等于前半部分的链表

当链表的节点数为奇数时

bcff4f806f31497ab8b9de1950a8846f.png

1d6417c77b904561bbf51bbaa4175859.png

800d75ea12ed434cbe446f03e3efc2e8.png

当链表的节点数为偶数时

117ca253eb674e2eab0e81bb66f0ada3.png

cbf0dbabb6b041b589354bcd20da4e3c.png

8f8dc48437e043e9b4ee8ce7e1f9e7e7.png

30e7abb8662d492ebd8c6a0d1e34b1cd.png

c686d684250d4aa9af6e07955037d4c1.png

9f6865d0dd33424e873041be14d3eebd.png

b6d44004bd974ff28ce748c4b058b72a.png

在执行这一步的时候我们需要注意:当链表的节点数为偶数跟奇数的时候,我们需要做出不同的判断来看前半部分的链表跟后半部分的链表是否走完了。

我们假设前半部分是从head1开始走的,后半部分的链表是从head2开始走的。当链表的节点数为奇数的时候,当head1跟head2相遇的时候就说明判断结束了。当链表的节点数为偶数的时候,当

head1.next = head2的时候,我们就可以说判断结束了。

  1. ListNode head1 = head;
  2. ListNode head2 = slow;
  3. while(head1 != head2) {
  4. if(head1.val != head2.val) {
  5. return false;
  6. }
  7. if(head1.next == head2) {
  8. return true;
  9. }
  10. head1 = head1.next;
  11. head2 = head2.next;
  12. }
  13. return true;

整体代码展示

  1. class Solution {
  2. public boolean isPalindrome(ListNode head) {
  3. if(head == null) return false;
  4. ListNode slow = head;
  5. ListNode fast = head;
  6. while(fast != null && fast.next != null) {
  7. slow = slow.next;
  8. fast = fast.next.next;
  9. }
  10. ListNode cur = slow.next;
  11. while(cur != null) {
  12. ListNode nextNode = cur.next;
  13. cur.next = slow;
  14. slow = cur;
  15. cur = nextNode;
  16. }
  17. while(head != slow ){
  18. if(head.val != slow.val) {
  19. return false;
  20. }
  21. if(head.next == slow) return true;
  22. head = head.next;
  23. slow = slow.next;
  24. }
  25. return true;
  26. }
  27. }

总结:

所以这道题你学会了吗?感谢大家的观看,以后也会更新关于C语言跟Java相关的知识,关注不迷路哦!!!

发表评论

表情:
评论列表 (有 0 条评论,115人围观)

还没有评论,来说两句吧...

相关阅读