palindrome linked list

#include <bits/stdc++.h> 
/****************************************************************

    Following is the class structure of the LinkedListNode class:

    template <typename T>
    class LinkedListNode
    {
    public:
        T data;
        LinkedListNode<T> *next;
        LinkedListNode(T data)
        {
            this->data = data;
            this->next = NULL;
        }
    };

*****************************************************************/
// S.C->O(N)
//T.C->O(N)
bool palindrome(vector<int>ans){

    int s=0;

    int e=ans.size()-1;

    while(s<=e){

        if(ans[s]!=ans[e]){

            return 0;

        }

        s++;

        e--;

    }

    return 1;

}

bool isPalindrome(LinkedListNode<int> *head) {

    // Write your code here.

 

    vector<int>ans;

 

    LinkedListNode<int> *temp=head;

 

    while(temp!=NULL){

        ans.push_back(temp->data);

        temp=temp->next;

    }

 

    return palindrome(ans);

 

}

/*
    T.C->O(N)
    S.C->O(1)
    LinkedListNode<int> *reverse(LinkedListNode<int> *head) {

    // Creating node for remembering previous node in Linked List.
    LinkedListNode<int> *reverseHead = NULL;

    // Creating temporory node.
    LinkedListNode<int> *current = head;

    while (current != NULL) {

        LinkedListNode<int> *currentNext = current->next;
        current->next = reverseHead;
        reverseHead = current;
        current = currentNext;

    }

    // Return reverse Linked List.
    return reverseHead;

}

bool isPalindrome(LinkedListNode<int> *head) {

    LinkedListNode<int> *slow = head;
    LinkedListNode<int> *fast = head;
    LinkedListNode<int> *prev = head;

    // Find the middle node using TORTOISE-HARE-APPROACH.
    while (fast != NULL && fast->next != NULL) {
        prev = slow;
        fast = fast->next->next;
        slow = slow->next;
    }

    
    if (fast != NULL) {
        slow = slow->next;
    }

    // When there is only one node in given Linked List.
    if (slow == NULL) {
        return true;
    }

    // Dividing Linked LIst in two part by pointing prev next to NULL.
    prev->next = NULL;

    // Now reverse the second half.
    LinkedListNode<int> *reverseHead = reverse(slow);

    // Iterate through both LinkedList and then compare it.
    while (head != NULL) {

        if (head->data != reverseHead->data) {
            return false;
        }
        reverseHead = reverseHead->next;
        head = head->next;

    }

    return true;

}
*/