C++ LeetCode 234 回文链表

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2 输出: false

示例 2:

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

数组判断

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> vec;
        while(head!=nullptr)
        {
            vec.push_back(head->val);
            head=head->next;
        }
       int i=0;
       int j=vec.size()-1;
       while(i<=j)
       {
           if(vec[i]!=vec[j])
                return false;
            i++;
            j--;
       }
       return true;
    }
};

递归

一个指针保存与后面节点比较最前的节点；
递归遍历到最后一个节点，与前面指针比较，不相等就返回false，否则指针指向下一个，递归回溯继续比较。
ps：效率低，创建太多堆栈帧了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
    ListNode* frontPoint=nullptr;
public:
    bool  Palindrome_check(ListNode* head)
    {
        if(head)
        {
            if(!Palindrome_check(head->next))
                return false;
            if(frontPoint->val!=head->val)
                return false;
            frontPoint=frontPoint->next;
        }
        return true;
    }
    bool isPalindrome(ListNode* head) {
        frontPoint=head;
        return Palindrome_check(head);
    }
};

快慢指针

利用快慢指针找中心节点，反转前面链表，和后面部分依次比较，注意处理奇数项链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode* fastPoint=head;
        ListNode* index=head;
        ListNode* pre=nullptr;
        while(fastPoint&&fastPoint->next)
        {
            fastPoint=fastPoint->next->next;//快指针
            ListNode* temp=index->next;
            index->next=pre;//反转链表
            pre=index;
            index=temp;
        }
        if(fastPoint)//处理奇数链表
            index=index->next;
        while(pre)//比较
        {
            if(pre->val!=index->val)
                return false;
            pre=pre->next;
            index=index->next;
        }
        return true;
    }
};

stack栈

利用栈后进先出性质。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        stack<ListNode*> st;
        ListNode* index=head;
        int cnt=0;
        while(index)
        {
            st.push(index);
            index=index->next;
            cnt++;
        }
        cnt=cnt/2;
        index=head;
        while(cnt--)
        {
            if(index->val!=st.top()->val)
                return false;
            index=index->next;
            st.pop();
        }
        return true;

    }
};