/**
* 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 指针当前指向的节点,这个节点就是链表前半部分的最后一个节点。
}
};