牛客网:链表的回文结构(图文并茂)

题目描述

链表的回文结构

对于一个链表,请设计一个**时间复杂度为O(n),额外空间复杂度为O(1)**的算法,判断其是否为回文结构。

给定一个链表的头指针A,请返回一个bool值,代表其是否为回文结构。保证链表长度小于等于900

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

题解

先用快慢指针得到该链表的中间结点和尾结点,然后再将中间结点所指向的位置往后进行逆置,得到的逆置后的链表和原链表的val一 一做比较,如果都相等,则为回文结构。

初始情况:
在这里插入图片描述
mid 为慢指针,最终会走到中间结点,tail为快指针,最终会走到尾结点
①mid 一次走一个,tail一次走两个,直到 tail == NULL或 tail -> next == NULL为止。
在这里插入图片描述
②将mid 所指的位置向后进行逆置,如果tail == NULL,则说明该链表的长度为偶数个,在逆置时直接逆置mid所指位置即可,若tail->next == NULL,则说明链表的长度为奇数个,则在逆置时需要逆置mid->next位置的链表
在这里插入图片描述
tmp为逆置后链表的指针,head为原链表的头指针
③将head 和 tmp的val做比较,如果相等就向下走,不相等就返回false,直到 tmp == NULL(链表为奇数个) 或者 head == tmp时结束(链表为偶数个)
在这里插入图片描述

题解代码

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        // write code here
        if(A == NULL || A->next == NULL )
        {
            return false;
        }
        //先用快慢指针得到中间结点和最后一个结点
        struct ListNode* head = A;
        struct ListNode* mid = A;
        struct ListNode* tail = A;
        //struct ListNode* midMove = NULL;
        //获得头尾指针
        while(tail)
        {
           
            mid = mid->next;
            if(tail->next == NULL){
                //表明链表个数为奇数个
                //则中间移动指针要向后走一个
                //midMove = mid;
                mid = mid->next;
                break;
            }
            else if(tail->next->next == NULL)
            { //表明链表个数为偶数个
                mid = mid->next;
                tail = tail->next;
                //midMove = mid;
                break;
            }
            else{
                tail = tail->next->next;
            }
        }
        //将mid指向的链表逆置
        struct ListNode* tmp = reverseList(mid);
        while(tmp && head->next != tmp)
        {
            if(tmp->val != head->val)
            {
                return false;
            }
            else{
                tmp = tmp->next;
                head = head->next;
            }
        }
       return true;
    }
    //逆置链表
     struct ListNode* reverseList(ListNode* A)
     {
         if(A == NULL || A->next == NULL)
         {
             return A;
         }
         struct ListNode* head,* tail,* tmp;
         head = A;
         tail = A->next;
         head->next = NULL;
         while(tail)
         {
             tmp = tail->next;
             tail->next = head;
             head = tail;
             tail = tmp;
         }
         return head;
     }
};
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 可以使用快慢指针找到链表中点,然后将链表的后半部分反转,最后比较前半部分和反转后的后半部分是否相等即可。 具体步骤如下: 1. 定义快慢指针,将快指针每次移动两个节点,慢指针每次移动一个节点,直到快指针到达链表末尾,此时慢指针指向链表中点。 2. 反转链表的后半部分,从中点开始,使用三个指针依次将链表节点反转。 3. 比较前半部分和反转后的后半部分是否相等,如果相等,则链表回文结构,返回1,否则返回0。 代码实现如下: ### 回答2: 要判断一个链表是否是回文结构,可以使用双指针法和栈来实现。 首先,使用快慢指针找到链表的中间节点。慢指针每次移动一个节点,快指针每次移动两个节点,当快指针到达链表末尾时,慢指针指向链表的中间节点。 然后,将链表后半部分的节点压入栈中。从中间节点的下一个节点开始,依次将节点压入栈中,直到快指针到达链表末尾。 最后,从链表的头节点开始,与栈中的节点进行比较。依次弹出栈中的节点,与当前链表节点比较,如果不相等,则该链表不是回文结构,返回0;如果所有节点都相等,则该链表回文结构,返回1。 以下是具体的代码实现: ```python class ListNode: def __init__(self, x): self.val = x self.next = None def isPalindrome(head): if not head or not head.next: return 1 # 快慢指针找到链表的中间节点 slow = fast = head while fast.next and fast.next.next: slow = slow.next fast = fast.next.next # 将后半部分的节点压入栈中 stack = [] cur = slow.next while cur: stack.append(cur) cur = cur.next # 从链表头节点开始与栈中的节点进行比较 cur = head while stack: if cur.val != stack.pop().val: return 0 cur = cur.next return 1 ``` 这样我们就可以通过调用isPalindrome函数,判断一个链表是否是回文结构。返回1表示是回文结构,返回0表示不是回文结构。 注意,上述代码是基于Python语言的实现,对于其他语言可能需要稍作调整。 ### 回答3: 要判断一个链表是否是回文结构,可以使用快慢指针找到链表的中间节点,并将后半部分反转,然后逐个比较前半部分和反转后的后半部分是否相等。 具体步骤如下: 1. 定义快慢指针slow和fast,初始时都指向链表的头部。 2. 使用快慢指针找到链表的中间节点,当fast指针到达链表末尾时,slow指针刚好指向链表中间节点。 3. 反转slow指针之后的链表。 4. 分别使用两个指针分别指向链表的头部和反转后的链表的头部。 5. 逐个比较两个链表中的节点值,如果有不相等的节点,则不是回文结构,输出0;否则,是回文结构,输出1。 下面是具体实现的代码: ```python class ListNode: def __init__(self, x): self.val = x self.next = None def reverseList(head): prev = None curr = head while curr: next_node = curr.next curr.next = prev prev = curr curr = next_node return prev def isPalindrome(head): if not head or not head.next: return 1 slow, fast = head, head while fast.next and fast.next.next: slow = slow.next fast = fast.next.next second_half = reverseList(slow.next) p1, p2 = head, second_half while p1 and p2: if p1.val != p2.val: return 0 p1 = p1.next p2 = p2.next return 1 ``` 时间复杂度分析:快慢指针遍历链表的时间复杂度为O(n),反转后半部分链表的时间复杂度为O(n/2),遍历比较两个链表的时间复杂度为O(n/2),所以总时间复杂度为O(n)。 空间复杂度分析:反转后半部分链表时需要使用一个额外的指针来储存当前节点的下一个节点,所以空间复杂度为O(1)。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值