OR36 链表的回文结构-C语言

题目来源:牛客网

题目描述:

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

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

测试样例:

1->2->2->1
返回:true

代码:

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    while(fast&&fast->next){
        fast=fast->next->next;
        slow=slow->next;
    }
    return slow;
}

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* newhead=NULL;
    struct ListNode* cur=head;
    while(cur){
            struct ListNode* next=cur->next;
            cur->next=newhead;
            newhead=cur;
            cur=next;
    }
    return newhead;
}

class PalindromeList {
public:
    bool chkPalindrome(ListNode* head) {
        ListNode* mid=middleNode(head);
        ListNode* rhead=reverseList(mid);
        while(rhead&&head){
            if(rhead->val!=head->val){
                return false;
            }
            rhead=rhead->next;
            head=head->next;
        }
        return true;
    }
};

思路:我们先找到链表的中间节点,比如1,2,2,1,我们找到第二个2,如果是1,2,3,2,1,我们就找到3,然后从这里开始对链表进行逆置,即1,2变为2,1,此时就会变为1,2,1,2我们再对链表顺序比较即可,链表的求中间节点和逆置我们之前是写过的,我这里再放一下链接

(1条消息) 206. 反转链表-C语言_KLZUQ的博客-CSDN博客

(1条消息) 876. 链表的中间结点-C语言_KLZUQ的博客-CSDN博客

 

 

  • 0
    点赞
  • 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、付费专栏及课程。

余额充值