Detecting a palindrome linked list by converting it into a String

I am supposed to check if a linked list is a palindrome or not, so I traversed through the LL and converted all the elements into a String, then passed the String to a function which determines if it's a palindrome or not.

Is this approach correct? Is it suitable to use this approach during interviews and tests?

The method I found online reversed the LL and then compared all the values one by one, but honestly it seemed my method was simpler. Here is my code snippet:

public static boolean isPalindromeString(String s) {
    int n = s.length();

    for (int i = 0; i < (n/2); i++) {
        if (s.charAt(i) != s.charAt(n - i - 1))
            return false;
    }

    return true;
}

public static boolean isPalindrome(LinkedListNode<Integer> head) {    
    if(head == null)
        return true; //when list is empty, it is a palindrome
    
    StringBuilder s = new StringBuilder();
    
    while(head != null){
        s.append(head.data);
        head = head.next;
    }

    // System.out.println("LL as string: " + s.toString());

    return isPalindromeString(s.toString());
}

Try to add a few lines of code such as
on the third line add this:

int itr = n-1;

now replace this:

if (s.charAt(i) != s.charAt(n - i - 1))

with:

if (s.charAt(i) != s.charAt(itr))

and at the end add the below line after the ending of if statement with in for loop:

itr--;

Depends on how you define palindrome here.

• Is this list a palindrome? [1, 2, 3, 321]?
• How about [10, 20, 10]?
• Or what about [-5, -5]?

If the answers are respectively 'yes', 'no', and 'no', then your code does the job, otherwise it won't.

Furthermore, if that linkedlistnode you're getting (it's not standard java, must be part of your homework exercise) is a so-called doubly linked list (which means: You can iterate through it backwards just as well as forwards, and there is a way to get the last element quickly and easily), then there is a much more efficient way to do this. If not, this approach is fine.

Your method is simple, yet more memory and processor taxing.

The beauty of linked list lies in its memory efficiency when handling large number of elements. Each Node object of a linked list is stored on the heap memory separately. This eliminates the need for allocating huge contiguous space for large lists. This results in memory efficient, but additional time complexity. Reversing linked list is also much easier. You just have to replace the next node with proper one. Often java linked lists have a last parameter which makes it easier to reverse. (Worst case singly linked list might take O(n**2) and Double linked list takes O(n) time)

When you add each element to StringBuilder object and the converting it to a single string, the final string takes up a contiguous block of memory. If the resulting string is very large, the toll on memory would also be higher. Plus, String object has some other overheads which linked list doesn't have. (Check this for more info: https://www.javamex.com/tutorials/memory/string_memory_usage.shtml)

So, although your algorithm works, it might be inefficient when handling large lists.