第八天：回文链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    //反转链表
    ListNode* reverse(ListNode* pre, ListNode* cur)
    {
        if(cur == nullptr)  return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        return reverse(cur, temp);
    }
    //创建链表的副本
ListNode* copyList(ListNode* head) {
    if (head == nullptr) return nullptr;

    ListNode* newHead = new ListNode(head->val);//创建了新链表的头节点，并将其值设置为原链表头节点的值。
    ListNode* newCurrent = newHead;//用于跟踪新链表的当前节点，初始时指向新链表的头节点。
    ListNode* current = head->next;//用于跟踪原链表的当前节点，初始时指向原链表的第二个节点。

    while (current != nullptr) {//原链表不为空，就一致循环
        newCurrent->next = new ListNode(current->val);///逐渐使用原链表中的val值创建一个新节点，
        newCurrent = newCurrent->next;
        current = current->next;
    }

    return newHead;
}
    bool isPalindrome(ListNode* head) {
        //判断第i个和第n-1-i个结点是否相等；第i个结点以此遍历即可，那第n-i-1个结点要如何获得呢？
            //直线思考1：将该链表进行反转，然后比对翻转前和反转后时候相等；
            //得到反转链表后，通过一个while循环，如果有不相等的元素，跳出while循环，return false；if遍历到最后head确实是null，则return true
        if(head == nullptr) return true;
        ListNode* rehead = copyList(head);
        ListNode * res = reverse(nullptr,rehead);//得到反转链表
        while(head != nullptr)
        {
            if(head->val != res->val) return false;
            head = head->next;
            res = res->next;
        }
        return true;
    }
};

使用栈来做：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        //使用栈来做
        stack<int> stk;
        ListNode* cur = head;
        while(cur != nullptr)//将列表中的值都装入栈中
        {
            stk.push(cur->val);
            cur = cur->next;
        }
        cur = head;
        int n = stk.size();
        while(n--)
        {
            int q = stk.top();
            if(q != cur->val)   return false;
            cur = cur->next;
            stk.pop();
        }
        return true;


    }
};

将链表中的值存到数组中，在用双指针来做：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> res;
        while(head != nullptr)
        {
            res.push_back(head->val);
            head = head->next;
        }
        int i = 0;
        int j = res.size() - 1;
       while(i < j)
       {
            if(res[i] != res[j])    return false;
            i++;
            j--;
       }
       return true;

    }
};

反转链表的后半部分（使用快慢指针找到前半部分的最后一个节点），然后将两个部分链表进行一一比较；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head == nullptr) return true;
        //找到前半部分链表的尾节点，并反转后半部分链表
        ListNode* firstHalfEnd = end0FirstHalf(head);
        ListNode* secondHalfStart = reverseList(firstHalfEnd->next);

        //判断是否回文
        ListNode* p1 = head;
        ListNode* p2 = secondHalfStart;
        bool result = true;
        while(result && p2 != nullptr)
        {
            if(p1->val != p2->val)  result = false;
            p1=p1->next;
            p2= p2->next;
        }
        //还原链表（对反转的链表再反转一遍）
        firstHalfEnd->next = reverseList(secondHalfStart);
        return result;


    }
    //反转链表
    ListNode* reverseList(ListNode* head)
    {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        while(curr != nullptr)
        {
            ListNode* temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }




    //找到链表前半部分的最后一个节点
    // fast一次移动两个节点，slow一次移动一个节点
    // 当fast指针到达链表末尾或倒数第二个节点时，slow正好到达链表中间节点或前半部分的最后一个节点
    ListNode* end0FirstHalf(ListNode* head)
    {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast->next != nullptr && fast->next->next != nullptr)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;//返回 slow 指针当前指向的节点，这个节点就是链表前半部分的最后一个节点。
    }
};