C++判断一个链表是否为回文结构

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)。也就是不准使用辅助空间，这个时候怎么办了？

1. 首先用一个快指针，一个慢指针来遍历链表。快指针每次走两步，慢指针每次走一步。等到快指针遍历完链表，慢指针就正好停留在链表的中央。
2. 将链表的后半部分进行反转。
3. 将链表的前半部分与后半部分逐个比对。若都相同，则为回文链表，否则不是。
4. 将反转之后右半部分的链表进行恢复.

4. 代码

4.1 程序说明：

这里我们实现了三个函数进行判断是否为回文链表，分别是：

1. isPalindrome1 使用$O(N)$辅助空间,对应基础版本．
2. isPalindrome２ 使用$O(N/2)$辅助空间，对应基础版本．
3. isPalindrome3 使用$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函数还是有点复杂的，这个节点的指向有点绕晕了．