Fork me on GitHub

回文链表

    回文链表其实也是链表反转的变形;也可以用栈实现。

//对于一个链表,请设计一个时间复杂度为O(n), 额外空间复杂度为O(1)的算法,判断其是否为回文结构。
//给定一个链表的头指针A,请返回一个bool值,代表其是否为回文结构。保证链表长度小于等于900。
//测试样例:
//1->2->2->1
//返回:true

#include <stdio.h>
#include <iostream>
using namespace  std;

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};


//思路1:空间O(n) 整个链表遍历两边, 开一个栈,第一遍遍历把链表中每个元素push进栈中,这样堆中的元素的pop顺序就是链表的倒序输出;第二遍就开始pop栈中数据,每pop一个数据,就把这个数据跟链表中进行对比,如果相同继续往下走,如果不同返回false。
//
//思路2:空间O(1),使用快慢指针法,第一步设置一个块指针和一个慢指针,快指针一次走两步,慢指针一次走一步(慢),当快指针下一步为null的时候说明慢指针已经走了一半,这就可以找到中间节点。第二步反转中间链表后面的指针,第三部从头尾向中间扫描,对比每个元素是否相等,如果都相等,则是回文数,否则不是回文数。(下面网友易水给出了代码实现,这里不再叙述)

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        // write code here
    
        ListNode* pSlow = A;
        ListNode* pQucik = A;
        //快慢指针找到中间节点
        while (pQucik!=nullptr&&pQucik->next!=nullptr)
        {
            pQucik = pQucik->next->next;
            pSlow = pSlow->next;
            
        }
        //将中点结点后的指针反转
        ListNode* pNode = nullptr;
        pNode = pSlow->next;
        ListNode* pHead = pSlow;  //反转链表的头
        while (pNode!=nullptr)   //测试未通过
        {
            ListNode* temp = pNode;
            pNode = pNode->next;
            temp->next = pHead;
            pHead = temp;
        }
        while (A!=pHead)
        {
            if (A->val!=pHead->val)
            {
                return false;
            }
            A = A->next;
            pHead = pHead->next;
        }
        return true;
    }
};

class PalindromeList1 {
public:
    bool chkPalindrome(ListNode* A) {  //A不带头节点
        // write code here
        if (A == nullptr || A->next == nullptr)
            return true;
        ListNode* head = nullptr;
        ListNode* node = A;

    /*    //将中间节点后的指针反转        
        ListNode* p = slow->next;
        ListNode* p1 = p->next;
        while (p != NULL){
            p->next = slow;
            slow = p;
            p = p1;
            p1 = p1->next;
        }*/

        while (node != nullptr){
            ListNode* temp = node;
            node = node->next;
            temp->next = head;
            head = temp;
        }
        while (A != nullptr&&head != nullptr){
            if (A->val != head->val){
                return false;
            }
            A = A->next;
            head = head->next;
        }
        return true;
    }
};

void print(ListNode* pHead)
{
    if (pHead==nullptr)
    {
        puts("链表为空!");
        return;
    }
    puts("链表为:");
    ListNode*pNode = pHead->next;
    while (pNode)
    {
        printf("%d ->", pNode->val);
        pNode = pNode->next;
    }
    cout << "NULL\n";
}

ListNode* create()
{
    ListNode* pHead, *pNode, *temp;
    int x;
    pHead = pNode = (ListNode*)malloc(sizeof(ListNode));  //带头节点的链表
    printf("请输入链表数据,以0为结束标志:\n");
    scanf("%d", &x);
    while (x)
    {
        temp = (ListNode*)malloc(sizeof(ListNode));
        temp->val = x;
        pNode->next = temp;
        pNode = temp;
        scanf("%d", &x);
    }
    pNode->next = nullptr;
    return pHead;
}


int main()
{
    ListNode *pHead = create();
    print(pHead);
    PalindromeList s;
    bool val=s.chkPalindrome(pHead);
    cout << val << endl;
    return 0;
}

 

posted @ 2016-06-30 11:06  ranjiewen  阅读(1385)  评论(0编辑  收藏  举报