234. Palindrome Linked List

来源：互联网发布：英国大学档次知乎编辑：程序博客网时间：2024/06/06 09:32

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;}

0 0