LeetCode/cpp/palindrome-linked-list.cpp

#include <cassert>
#include <vector>

/**
 * 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) {}
 * };
 */

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) {}
};

namespace {

struct middle_t {
    ListNode *node;
    std::size_t size;

    middle_t(ListNode *node, std::size_t size) : node(node), size(size) {}
};

middle_t find_middle(ListNode *head) {
    ListNode *slow = head;
    ListNode *fast = head->next;

    std::size_t size;
    for (size = 0; fast != nullptr && fast->next != nullptr; size++) {
        slow = slow->next;
        fast = fast->next->next;
    }

    return {slow, size};
}

ListNode *reverse_list(ListNode *tail) {
    ListNode *previous = nullptr;
    ListNode *next = nullptr;

    for (ListNode *current = tail; current != nullptr;
         previous = current, current = next) {
        next = current->next;
        current->next = previous;
    }

    return previous;
}

bool compare_lists(ListNode *left, ListNode *right, std::size_t size) {
    for (auto i = 0u; i < size + 1; i++) {
        if (left->val != right->val) {
            return false;
        }
        left = left->next;
        right = right->next;
    }

    return true;
}

} // namespace

class Solution {
  public:
    bool isPalindrome(ListNode *head) {
        // find middle of the linked list
        auto mid = find_middle(head);

        // reverse the tail of the linked list
        auto tail = reverse_list(mid.node);

        // compare head and tail
        return compare_lists(head, tail, mid.size);
    }
};

#pragma region Testing utilities
namespace {

ListNode *construct_list(const std::vector<int> &values) {
    ListNode *head = new ListNode(values.front());
    ListNode *tail = head;

    for (std::size_t i = 1; i < values.size(); i++) {
        tail->next = new ListNode(values[i]);
        tail = tail->next;
    }

    return head;
}

void destroy_list(ListNode *linked_list) {
    if (linked_list == nullptr) {
        return;
    }
    destroy_list(linked_list->next);
    delete linked_list;
}

bool test_find_middle(const std::vector<int> &values, int mid_value) {
    auto linked_list = construct_list(values);

    auto mid = find_middle(linked_list);
    auto result = mid.node->val == mid_value;

    destroy_list(linked_list);
    return result;
}

bool test_isPalindrome(const std::vector<int> &values) {
    auto linked_list = construct_list(values);

    Solution s;
    auto result = s.isPalindrome(linked_list);

    destroy_list(linked_list);
    return result;
}

} // namespace
#pragma endregion // Testing utilities

int main() {
    // find_middle tests
    assert(test_find_middle(std::vector{1, 2, 2, 1}, 2));
    assert(test_find_middle(std::vector{1, 2, 3, 2, 1}, 3));
    assert(test_find_middle(std::vector{1, 2}, 1));
    assert(test_find_middle(std::vector{1}, 1));

    // isPalindrome tests
    assert(test_isPalindrome(std::vector{1, 2, 2, 1}));
    assert(test_isPalindrome(std::vector{1, 2, 3, 2, 1}));
    assert(!test_isPalindrome(std::vector{1, 2}));
    assert(test_isPalindrome(std::vector{1}));

    return 0;
}