1. 题目描述(基础要求)
给定一个链表的头节点head,请判断该链表是否为回文结构。 例如: 1->2->1,返回true。 1->2->2->1,返回true。15->6->15,返回true。 1->2->3,返回false。
2. 思路
如果对空间复杂度没有要求的话,我们可以借助辅助空间.我们借助一个STL的stack将我们的value放到栈当中,然后对比的时候从栈顶弹出元素,如果有一个不相等则返回false,否则返回true; 进一步的话我们可以使用二个指针,一个快指针,一个慢指针,快指针一次走二步,慢指针一次走一步,当快指针到达终点的时候,慢指针刚好到达中点,然后我们将整个链表分成左和右二个部分,然后我们将右半部分压栈进行对比,这样就会节省一半的空间.
3. 进阶版本
如果程序进一步要求:如果链表长度为N,时间复杂度达到O(N),额外空间复杂度达到O(1)。也就是不准使用辅助空间,这个时候怎么办了?
- 首先用一个快指针,一个慢指针来遍历链表。快指针每次走两步,慢指针每次走一步。等到快指针遍历完链表,慢指针就正好停留在链表的中央。
- 将链表的后半部分进行反转。
- 将链表的前半部分与后半部分逐个比对。若都相同,则为回文链表,否则不是。
- 将反转之后右半部分的链表进行恢复.
4. 代码
4.1 程序说明:
这里我们实现了三个函数进行判断是否为回文链表,分别是:
isPalindrome1
使用 O ( N ) O(N) O(N)辅助空间,对应基础版本.isPalindrome2
使用 O ( N / 2 ) O(N/2) O(N/2)辅助空间,对应基础版本.isPalindrome3
使用 O ( 1 ) O(1) O(1)辅助空间,对应进阶版本.
#include <iostream>
#include <vector>
#include <stack>
struct ListNode {
int val;
struct ListNode* next;
ListNode(int x) :
val(x), next(nullptr) {
}
};
// need n extra space
bool isPalindrome1(ListNode* head) {
std::stack<int> my_node_value;
ListNode* curNode = head;
while (curNode != nullptr) {
my_node_value.push(curNode->val);
curNode = curNode -> next;
}
while (head!= nullptr) {
if (head -> val != my_node_value.top()) {
return false;
} else {
head = head -> next;
my_node_value.pop();
}
}
return true;
}
// need n/2 extra space
bool isPalindrome2(ListNode* head) {
if (head == nullptr || head -> next == nullptr) {
return true;
}
std::stack<int> my_node_value;
ListNode* slowNode = head -> next;
ListNode* fastNode = head;
while (fastNode -> next != nullptr && fastNode -> next -> next != nullptr) { // get the middle node
slowNode = slowNode -> next;
fastNode = fastNode -> next -> next;
}
while (slowNode != nullptr) {
my_node_value.push(slowNode -> val);
slowNode = slowNode -> next;
}
while (!my_node_value.empty()) { // here we can't use the condition: head != nullptr
if (head -> val != my_node_value.top()) {
return false;
break;
} else {
head = head -> next;
my_node_value.pop();
}
}
return true;
}
// need O(1) extra space
bool isPalindrome3(ListNode* head) {
if (head == nullptr || head -> next == nullptr) {
return true;
}
ListNode* n1 = head; // slow pointer
ListNode* n2 = head; // fast pointer
while (n2 -> next != nullptr && n2 -> next -> next != nullptr) {
n1 = n1 -> next;
n2 = n2 -> next -> next;
}
n2 = n1 -> next; // n2 now is the first node in the second list
n1 -> next = nullptr;
ListNode* n3 = nullptr; // A ListNode to store the last node in the second list
while (n2 != nullptr) {
n3 = n2 -> next;
n2 -> next = n1;
n1 = n2;
n2 = n3;
}
n3 = n1; // here n1 is the last node in the second list, we need to store the last node to reconver
n2 = head; // compare the first and the second list
while (n1 != nullptr && n2 != nullptr) {
if (n1 -> val != n2 -> val) {
return false;
break;
} else {
n1 = n1 -> next;
n2 = n2 -> next;
}
}
n1 = n3 -> next; // here we recover the second list to the origin order
n3 -> next = nullptr; // the origin last node next poiter is nullptr
while (n1 != nullptr) {
n2 = n1 -> next;
n1 -> next = n3;
n3 = n1;
n1 = n2;
}
return true;
}
void printList(ListNode* pHead) {
while (pHead != nullptr) {
std::cout << pHead -> val << ",";
pHead= pHead -> next;
}
std::cout << "\n";
}
int main()
{
ListNode* pHead = new ListNode(1);
pHead -> next = new ListNode(2);
pHead -> next -> next = new ListNode(1);
std::cout << "origin list is:" << std::endl;
printList(pHead);
bool is_palindrome = isPalindrome3(pHead);
if (is_palindrome) {
std::cout << "is palindrome" << std::endl;
} else {
std::cout << "not palindrome" << std::endl;
}
return 0;
}
这里的话我们列举了二种情况:一种是1 2 1 结构,另外一种是 1 2 3 结构,我们都得到了正确的结果,这里以isPalindrome3
函数为例子.
实现
isPalindrome3
函数还是有点复杂的,这个节点的指向有点绕晕了.