234. Palindrome Linked List

原创 2016年08月31日 16:19:07

Given a singly linked list, determine if it is a palindrome.

给定单链表,判断链表数据是否为回文。

Follow up:
Could you do it in O(n) time and O(1) space?

能否以O(n)的时间复杂度和O(1)空间复杂度实现?


首先尝试较为简单的实现——不考虑空间复杂度

获取链表的长度n,分配一个长度为n的一维数组空间,将链表元素顺序存入其中,再进行回文判断,代码如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool isPalindrome(struct ListNode* head) {
    int i,j=0;
    int n=getLinkListLenth(head);             //获取节点数目
    int* p=(int*)malloc(n*sizeof(int));
    for(i=0;i<n;i++)                          //将链表的数据顺序存储
    {
        *(p+i)=head->val;
        head=head->next;
    }
    for(i=0;i<n/2;i++)                        //回文检测
    {
        if(*(p+i)==*(p+n-1-i))
        j++;
        else 
        break;
    }
    return j==n/2?true:false;
}
int getLinkListLenth(struct ListNode* head)   //获取数组长度
{
    int length=1;
    if(NULL==head)
    return 0;
    while(head->next!=NULL)
    {
        head=head->next;
        length++;
    }
    return length;
}


其中程序时间花在三个地方:遍历链表(n)、链表顺序存储(n)以及回文判断(n/2)
时间复杂度为O(n),但空间复杂度也为O(n),该方法提交结果如下:


接下来再考虑缩小空间复杂度,在O(1)的空间复杂度要求下,显然不能再建立一个长度为n的数组,只能从链表本身入手。由于单链表访问的单向性,每次访问后半部分链表都需要遍历前半部分,这浪费了大量时间。考虑到回文的特性,我们可以找到链表的中心位置,将后半部分链表截取后进行反转,这样便得到了两个链表,且链表访问方向正好满足我们的要求,实现如下:
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool isPalindrome(struct ListNode *head) {
    int n,i,j=0;
    struct ListNode *middle,*p,*s,*t;
    middle=(struct ListNode*)malloc(sizeof(struct ListNode));
    middle->val=9;
    p=head;
    n=getLinklistLength(head);               //获取n和rear
    if(n<2)                                  //链表长度小于2
    return true;
    else if(n==2)
    return head->val==head->next->val?true:false;
    else if(n==3)
    return head->val==head->next->next->val?true:false;
    else
    {
        for(i=0;i<n/2-1;i++)                 //寻找中间节点前一个节点
            p=p->next;
        if(n%2==0)                           //偶数个节点
            middle->next=p->next;
        else
            middle->next=p->next->next;
        p->next=NULL;

        /*后半部分链表反转*/
        p=middle->next;
        s=p->next;
        p->next=NULL;
        while(s)               
        {
            t=s->next;
            s->next=p;
            p=s;
            s=t;
        }
        middle->next=p;

        /*回文判断*/
        p=head;
        s=middle->next;
        while(p!=NULL)
        {
            if(p->val==s->val)
            {
                p=p->next;
                s=s->next;
                j++;
            }
            else
            break;
        }
        return j==n/2?true:false;
    }
}

int getLinklistLength(struct ListNode* head)
{
    int length=1;
    if(NULL==head)
    length=0;
    else
    while(head->next!=NULL)
    {
        head=head->next;
        length++;
    }
    return length;
}
这里建立了一个中间节点middle,使其作为后半部分链表的头节点,这样一来程序能满足O(n)的时间复杂度和O(1)的空间复杂度要求,程序提交结果如下:
以上程序还可以进一步简化,middle节点可以不用分配内存,只作为一个指针即可:
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool isPalindrome(struct ListNode *head) {
    int n,i,j=0;
    struct ListNode *middle,*p,*s,*t;
    n=getLinklistLength(head);                //获取链表长度n
    if(n<2)                                   //链表长度小于2
        return true;
    else if(n==2)                             //链表长度等于2
        return head->val==head->next->val?true:false;
    else if(n==3)
        return head->val==head->next->next->val?true:false;
    else
    {
        p=head;
        for(i=0;i<n/2-1;i++)                  //寻找中间节点前一个节点
            p=p->next;
        middle=n%2==0?p->next:p->next->next;  //根据节点奇偶情况为middle指针
        p->next=NULL;                         //前半链表最后一个节点next指向NULL

        /*后半部分链表反转*/
        p=middle;
        s=p->next;
        p->next=NULL;
        while(s)               
        {
            t=s->next;
            s->next=p;
            p=s;
            s=t;
        }
        middle=p;                           //middle作为后半段链表的头指针

        /*回文判断*/
        p=head;
        s=middle;
        while(p)
        {
            if(p->val==s->val)
            {
                p=p->next;
                s=s->next;
                j++;
            }
            else
            break;
        }
        return j==n/2?true:false;
    }
}

int getLinklistLength(struct ListNode* head)
{
    int length=1;
    if(NULL==head)
    length=0;
    else
    while(head->next!=NULL)
    {
        head=head->next;
        length++;
    }
    return length;
}


版权声明:本文为博主原创文章,转载请声明出处:)

相关文章推荐

234. Palindrome Linked List(python)

Given a singly linked list, determine if it is a palindrome. Follow up: Could you do it in O(n) ti...

LeetCode 234: Palindrome Linked List (回文链表)

Given a singly linked list, determine if it is a palindrome.Follow up:Could you do it in O(n) time a...

Leetcode 234. Palindrome Linked List

234. Palindrome Linked List Total Accepted: 69120 Total Submissions: 225579 Difficulty: Easy ...

(LeetCode 234)Palindrome Linked List

Leetcode第234题目是Palindrome Linked List。题目的描述如下: Given a singly linked list, determine if it is a pali...

[LeetCode-234] Palindrome Linked List(回文链表、链表中间节点查找)

Given a singly linked list, determine if it is a palindrome. Follow up: Could you do it in O(n) tim...

[LeedCode OJ]#234 Palindrome Linked List

【 声明:版权所有,转载请标明出处,请勿用于商业用途。  联系信箱:libin493073668@sina.com】 题目链接:https://leetcode.com/prob...

【Leetcode】234. Palindrome Linked List

思路: 1、遍历整个链表,将链表每个节点的值记录在数组中,再判断数组是不是一个回文数组,时间复杂度为O(n),但空间复杂度也为O(n),不满足空间复杂度要求。 2、利用栈先进后出的性质,将链表前半段压...

[leetcode] 234.Palindrome Linked List

题目: Given a singly linked list, determine if it is a palindrome.Follow up: Could you do it in O(n)...

Leetcode_234_Palindrome Linked List

本文是在学习中的总结,欢迎转载但请注明出处:http://blog.csdn.net/pistolove/article/details/47334465 Given a singly lin...

LeetCode笔记:234. Palindrome Linked List

判断一个链表是否是回文
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:234. Palindrome Linked List
举报原因:
原因补充:

(最多只允许输入30个字)