Palindromic Linked List
You are given a singly Linked List of integers. Your task is to return true if the given singly linked list is a palindrome otherwise returns false.

For example:

The given linked list is 1 - 2 - 3 - 2- 1- NULL. It is a palindrome linked list because the given linked list has the same order of elements when traversed forwards and backward.

Follow Up:

Can you solve the problem in O(N) time complexity and O(1) space complexity iteratively?

Input format :

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows. The only line of each test case contains the elements of the singly linked list separated by a single space and terminated by -1. Hence, -1 would never be a list element.

Output format :

For each test case, print “true” or “false” in a separate line.

Note :

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1

Question

Palindromic Linked List

You are given a singly Linked List of integers. Your task is to return true if the given singly linked list is a palindrome otherwise returns false.

For example:

The given linked list is 1 -> 2 -> 3 -> 2-> 1-> NULL.

It is a palindrome linked list because the given linked list has the same order of elements when traversed forwards and backward.

Follow Up:

Can you solve the problem in O(N) time complexity and O(1) space complexity iteratively?

Input format :

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows.

The only line of each test case contains the elements of the singly linked list separated by a single space and terminated by -1. Hence, -1 would never be a list element.

Output format :

For each test case, print “true” or “false” in a separate line.

Note :

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1 <= T <= 10
0 <= L <= 10^5
1 <= data <= 10^9 and data != -1

Where L is the number of nodes in the Linked List.

Time Limit: 1 sec

Accepted Answer

Using Stack

The idea is to traverse the Linked List from head to tail and push every encountered node data into the stack.
Then we traverse the Linked List and for each node, we pop the top element from the stack and compare it with current node data of the Linked List. If they mismatch then the current linked list is not palindrome else if all elements match then the linked list is a palindrome.

Space Complexity: O(n)Explanation:

O(N), where N is the total number of nodes in the Linked List.

In the worst case, we are storing the all Linked List node value in the stack. Hence, overall complexity will be O(N).

Time Complexity: O(n)Explanation:

O(N), where N is the number of nodes in the Linked List.

In the worst case, we are traversing the whole linked list two times i.e O(N). Hence, the overall complexity is O(N).

Accepted Answer

Clone Linked List

The idea is to create a clone of Linked List and reverse it.
Now traverse both the Linked List and for each node data, we compare it, if they mismatch then the Linked List is not palindrome else if all elements match then the linked list is a palindrome.

Space Complexity: O(n)Explanation:

O(N), where N is the total number of nodes in the Linked List.

In the worst case, we are creating a new Linked List of N nodes. Hence, the overall complexity is O(N).

Time Complexity: O(n)Explanation:

O(N), where N is the number of nodes in the linked list.

In the worst case, we are traversing the whole Linked List two times i.e O(N). Hence, the overall complexity is O(N).

Accepted Answer

Recursion

The solution is to use a recursion stack. We will use two pointers left and right, one for the leftmost node and one for the rightmost node, of Linked List.
In each recursion call, we check
- Sub Linked list is a palindrome or not.
- Values at the current left and right are matching.
If both above conditions are true then return true from the current recursion.
At last, if all the recursion calls return true. We can conclude the given Linked List is a palindrome.

Steps:

Recursively traverse the entire linked list to get the last node as a rightmost node.
When we return from the last recursion stack. We will be at the last node of the Linked List. Then the last node value is compared with the first node value of Linked List.
In order to access the first node of Linked List, we create a global left pointer that points to the head of Linked List initially that will be available for every call of recursion and the right pointer which passes in the function parameter of recursion.
Now, if the left and right pointer node value is matched then return true from the current recursion call. Then the recursion falls back to (n-2)th node, and then we need a reference to the 2nd node from head. So we advance the left pointer in the previous call to refer to the next node in the Linked List.
If all the recursive calls are returning true, it means the given Linked List is a palindrome else it is not a palindrome.

Space Complexity: O(n)Explanation:

O(N), where N is the total number of nodes in the Linked List.

In the worst case, extra space is required for recursion stack.

Time Complexity: O(n)Explanation:

O(N), where N is the number of nodes in the linked list.

In the worst case, we are traversing the whole Linked List O(N) using recursion. Hence, the overall complexity will be O(N).

Accepted Answer

Reversing the Second Half

We divide the Linked list into two equal halves by finding the middle node of Linked List
To find the middle of the Linked List, we will create two pointers slow and fast which will point to the head of the given Linked List initially.
Then we will iterate the given Linked List using these pointers slow, and fast until the fast doesn't reach the end of Linked List and do the following in every step of the iteration:
- slow = slow.next
- fast = fast.next.next (the fast pointer will take a jump of 2 in each step. Thus when fast reaches the end of the linked list then the slow pointer will be either at the mid or near to the mid of the linked list).
Note:
- When the number of nodes is even then the first and second half contains equal nodes.
- But when the number of nodes is odd then there is one middle node so we don't consider it in both halves of Linked List.
Then we reverse the second half of the Linked List.
Now, we will compare the second half with the first half. If both the halves are exactly the same then the linked list is a palindrome, otherwise not.

Space Complexity: O(1)Explanation:

O(1).

In the worst case, we are using constant extra space.

Time Complexity: O(n)Explanation:

O(N), where N is the number of nodes in the Linked List.

In the worst case, finding the middle node in the Linked List takes O(N), reversing the second half takes O(N), and traversing the both Linked List again takes O(N). Hence, the overall complexity will be O(N).

You are given a singly Linked List of integers. Your task is to return true if the given singly linked list is a palindrome otherwise returns false.

For example:

Follow Up:

Input format :

Output format :

Note :

Constraints :

Top HSBC Group Software Engineer Trainee interview questions & answers

Popular interview questions of Software Engineer Trainee

Top HR questions asked in HSBC Group Software Engineer Trainee