Reverse Linked List

Given a singly linked list of integers. Your task is to return the head of the reversed linked list.

For example:
The given linked list is 1 -> 2 -> 3 -> 4-> NULL. Then the reverse linked list is 4 -> 3 -> 2 -> 1 -> NULL and the head of the reversed linked list will be 4.
Follow Up :
Can you solve this problem in O(N) time and O(1) space complexity?
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 the given linked list in reverse order 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 <= 5
0 <= L <= 10^5
1 <= data <= 10^9 and data != -1

Time Limit: 1 sec
CodingNinjas
author
2y
Brute Force

The brute force approach is to use recursion. First, we reach the end of the Linked List recursively and at last node, we return the last node, which becomes the new head of the partially r...read more

CodingNinjas
author
2y
Using Stack
  • Iterate through all nodes of the Linked list and push it to stack.
  • Then update the head pointer to the top node of the stack.
  • Then start popping each node from the stack and then assign the p...read more
CodingNinjas
author
2y
Using Recursion

We can improve our time complexity of finding the last node of partial reverse Linked List by the current node of each recursion call. If we look closer than the current node next is ac...read more

CodingNinjas
author
2y
Three Pointer Approach
  • Initially, we will take three-pointers, current that points to the head of Linked List, prev, and nextNode points to null.
  • Then we will iterate over the linked list until the curr...read more
CodingNinjas
author
2y
Two Pointer Approach

This approach is similar to the previous approach. While we are iterating the linked list we were swapping pointers using the third pointer, but in this approach, we will swap the pointers using only two pointers(one itself the given head) by using the property of XOR:

 

The property of XOR is:

 

  • X⊕X = 0
  • X⊕0 = X
  • X⊕Y = Y⊕X
  • (X⊕Y)⊕Z = X⊕(Y⊕Z)

 

Steps

 

  • Initially, we will take two-pointers, given head that points to the head of Linked List, prev, points to null.
  • Then we will iterate over the linked list until the current is not equal to NULL and do the following update in every step of the iteration:
    • prev = prev ⊕ head->next
    • head->next = prev ⊕ head->next
    • prev = prev ⊕ head->next
    • prev = prev ⊕ head
    • head= prev ⊕ head
    • prev = prev ⊕ head
  • Now return the prev pointer which is now the head of reverse Linked List.
Space Complexity: O(1)Explanation:

O(1)

 

In the worst case, only a constant extra space is required.

Time Complexity: O(n)Explanation:

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

 

In the worst-case, we are iterating the whole linked list O(N). Hence, the overall complexity will be O(N). 

Add answer anonymously...
Amazon Software Engineer Interview Questions
Stay ahead in your career. Get AmbitionBox app
qr-code
Helping over 1 Crore job seekers every month in choosing their right fit company
65 L+

Reviews

4 L+

Interviews

4 Cr+

Salaries

1 Cr+

Users/Month

Contribute to help millions
Get AmbitionBox app

Made with ❤️ in India. Trademarks belong to their respective owners. All rights reserved © 2024 Info Edge (India) Ltd.

Follow us
  • Youtube
  • Instagram
  • LinkedIn
  • Facebook
  • Twitter