Given a linked list, the task is to reverse the linked list by changing the links between nodes.
Examples:
Input: head: 1 -> 2 -> 3 -> 4 -> NULL
Output: head: 4 -> 3 -> 2 -> 1 -> NULL
Explanation: Reversed Linked List:
Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULL
Output: head: 5 -> 4 -> 3 -> 2 -> 1 -> NULL
Explanation: Reversed Linked List:
[Expected Approach] Using Iterative Method - O(n) Time and O(1) Space
The idea is to reverse the links of all nodes using three pointers:
- prev: pointer to keep track of the previous node
- curr: pointer to keep track of the current node
- next: pointer to keep track of the next node
Starting from the first node, initialize curr with the head of linked list and next with the next node of curr. Update the next pointer of curr with prev. Finally, move the three pointer by updating prev with curr and curr with next.
Follow the steps below to solve the problem:
- Initialize three pointers prev as NULL, curr as head, and next as NULL.
- Iterate through the linked list. In a loop, do the following:
- Store the next node, next = curr -> next
- Update the next pointer of curr to prev, curr -> next = prev
- Update prev as curr and curr as next, prev = curr and curr = next
C++ // Iterative C++ program to reverse a linked list #include <iostream> using namespace std; class Node { public: int data; Node *next; Node(int new_data) { data = new_data; next = nullptr; } }; // Given the head of a list, reverse the list and // return the head of reversed list Node *reverseList(Node *head) { // Initialize three pointers: curr, prev and next Node *curr = head, *prev = nullptr, *next; // Traverse all the nodes of Linked List while (curr != nullptr) { // Store next next = curr->next; // Reverse current node's next pointer curr->next = prev; // Move pointers one position ahead prev = curr; curr = next; } // Return the head of reversed linked list return prev; } void printList(Node *node) { while (node != nullptr) { cout << " " << node->data; node = node->next; } } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node *head = new Node(1); head->next = new Node(2); head->next->next = new Node(3); head->next->next->next = new Node(4); head->next->next->next->next = new Node(5); cout << "Given Linked list:"; printList(head); head = reverseList(head); cout << "\nReversed Linked List:"; printList(head); return 0; } // Iterative C program to reverse a linked list #include <stdio.h> struct Node { int data; struct Node* next; }; // Given the head of a list, reverse the list and return the // head of reversed list struct Node* reverseList(struct Node* head) { // Initialize three pointers: curr, prev and next struct Node *curr = head, *prev = NULL, *next; // Traverse all the nodes of Linked List while (curr != NULL) { // Store next next = curr->next; // Reverse current node's next pointer curr->next = prev; // Move pointers one position ahead prev = curr; curr = next; } // Return the head of reversed linked list return prev; } void printList(struct Node* node) { while (node != NULL) { printf(" %d", node->data); node = node->next; } } struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 struct Node* head = createNode(1); head->next = createNode(2); head->next->next = createNode(3); head->next->next->next = createNode(4); head->next->next->next->next = createNode(5); printf("Given Linked list:"); printList(head); head = reverseList(head); printf("\nReversed Linked List:"); printList(head); return 0; } // Iterative Java program to reverse a linked list class Node { int data; Node next; Node(int new_data) { data = new_data; next = null; } } // Given the head of a list, reverse the list and return the // head of reversed list class GfG { static Node reverseList(Node head) { // Initialize three pointers: curr, prev and next Node curr = head, prev = null, next; // Traverse all the nodes of Linked List while (curr != null) { // Store next next = curr.next; // Reverse current node's next pointer curr.next = prev; // Move pointers one position ahead prev = curr; curr = next; } // Return the head of reversed linked list return prev; } // This function prints the contents // of the linked list starting from the head static void printList(Node node) { while (node != null) { System.out.print(" " + node.data); node = node.next; } } public static void main(String[] args) { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); System.out.print("Given Linked list:"); printList(head); head = reverseList(head); System.out.print("\nReversed Linked List:"); printList(head); } } # Iterative Python program to reverse a linked list class Node: def __init__(self, newData): self.data = newData self.next = None # Given the head of a list, reverse the list and return the # head of reversed list def reverseList(head): # Initialize three pointers: curr, prev and next curr = head prev = None # Traverse all the nodes of Linked List while curr is not None: # Store next nextNode = curr.next # Reverse current node's next pointer curr.next = prev # Move pointers one position ahead prev = curr curr = nextNode # Return the head of reversed linked list return prev def printList(node): while node is not None: print(f" {node.data}", end="") node = node.next print() if __name__ == "__main__": # Create a hard-coded linked list: # 1 -> 2 -> 3 -> 4 -> 5 head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5) print("Given Linked list:", end="") printList(head) head = reverseList(head) print("Reversed Linked List:", end="") printList(head) // Iterative C# program to reverse a linked list using System; class Node { public int Data; public Node Next; public Node(int newData) { Data = newData; Next = null; } } // Given the head of a list, reverse the list and return the // head of reversed list class GfG { static Node ReverseList(Node head) { // Initialize three pointers: curr, prev and next Node curr = head; Node prev = null; Node next; // Traverse all the nodes of Linked List while (curr != null) { // Store next next = curr.Next; // Reverse current node's next pointer curr.Next = prev; // Move pointers one position ahead prev = curr; curr = next; } // Return the head of reversed linked list return prev; } static void PrintList(Node node) { while (node != null) { Console.Write(" " + node.Data); node = node.Next; } Console.WriteLine(); } static void Main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.Next = new Node(2); head.Next.Next = new Node(3); head.Next.Next.Next = new Node(4); head.Next.Next.Next.Next = new Node(5); Console.Write("Given Linked list:"); PrintList(head); head = ReverseList(head); Console.Write("Reversed Linked List:"); PrintList(head); } } // Iterative JavaScript program to reverse a linked list class Node { constructor(newData) { this.data = newData; this.next = null; } } // Given the head of a list, reverse the list and return the // head of reversed list function reverseList(head) { // Initialize three pointers: curr, prev and next let curr = head; let prev = null; let next; // Traverse all the nodes of Linked List while (curr !== null) { // Store next next = curr.next; // Reverse current node's next pointer curr.next = prev; // Move pointers one position ahead prev = curr; curr = next; } // Return the head of reversed linked list return prev; } function printList(node) { while (node !== null) { console.log(" " + node.data); node = node.next; } console.log(); } // Driver Code // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); console.log("Given Linked list:"); printList(head); head = reverseList(head); console.log("Reversed Linked List:"); printList(head); OutputGiven Linked list: 1 2 3 4 5 Reversed Linked List: 5 4 3 2 1
[Alternate Approach - 1] Using Recursion - O(n) Time and O(n) Space
The idea is to reach the last node of the linked list using recursion then start reversing the linked list from the last node.
Follow the steps below to solve the problem:
- Divide the list in two parts - first node and rest of the linked list.
- Call reverse for the rest of the linked list.
- Link the rest linked list to first.
- Fix head pointer to NULL.
C++ // Recursive C++ program to reverse a linked list #include <bits/stdc++.h> using namespace std; class Node { public: int data; Node *next; Node(int new_data) { data = new_data; next = nullptr; } }; // Given the head of a list, reverse the list // and return the head of reversed list Node *reverseList(Node *head) { if (head == NULL || head->next == NULL) return head; // reverse the rest of linked list and put // the first element at the end Node *rest = reverseList(head->next); // Make the current head as last node of // remaining linked list head->next->next = head; // Update next of current head to NULL head->next = NULL; // Return the reversed linked list return rest; } void printList(Node *node) { while (node != nullptr) { cout << " " << node->data; node = node->next; } } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node *head = new Node(1); head->next = new Node(2); head->next->next = new Node(3); head->next->next->next = new Node(4); head->next->next->next->next = new Node(5); cout << "Given Linked List:"; printList(head); head = reverseList(head); cout << "\nReversed Linked List:"; printList(head); return 0; } // Recursive C program to reverse a linked list #include <stdio.h> struct Node { int data; struct Node* next; }; // Given the head of a list, reverse the list and // return the head of reversed list struct Node* reverseList(struct Node* head) { if (head == NULL || head->next == NULL) return head; // reverse the rest of linked list and put // the first element at the end struct Node* rest = reverseList(head->next); // Make the current head as last node of // remaining linked list head->next->next = head; // Update next of current head to NULL head->next = NULL; // Return the reversed linked list return rest; } // This function prints the contents // of the linked list starting from the head void printList(struct Node* node) { while (node != NULL) { printf(" %d", node->data); node = node->next; } printf("\n"); } struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 struct Node* head = createNode(1); head->next = createNode(2); head->next->next = createNode(3); head->next->next->next = createNode(4); head->next->next->next->next = createNode(5); printf("Given Linked List:"); printList(head); head = reverseList(head); printf("Reversed Linked List:"); printList(head); return 0; } // Recursive Java program to reverse a linked list class Node { int data; Node next; Node(int new_data) { data = new_data; next = null; } } class GfG { // Given the head of a list, reverse the list // and return the head of reversed list static Node reverseList(Node head) { // If we have reached last node or linked // list is empty, return head of linked list if (head == null || head.next == null) return head; // reverse the rest of linked list and put // the first element at the end Node rest = reverseList(head.next); // Make the current head as last node of // remaining linked list head.next.next = head; // Update next of current head to NULL head.next = null; // Return the reversed linked list return rest; } // This function prints the contents // of the linked list starting from the head static void printList(Node node) { while (node != null) { System.out.print(" " + node.data); node = node.next; } } public static void main(String[] args) { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); System.out.print("Given Linked List:"); printList(head); head = reverseList(head); System.out.print("\nReversed Linked List:"); printList(head); } } # Recursive Python program to reverse a linked list class Node: def __init__(self, newData): self.data = newData self.next = None # Given the head of a list, reverse the list and # return the head of reversed list def reverseList(head): if head is None or head.next is None: return head # reverse the rest of linked list and put the # first element at the end rest = reverseList(head.next) # Make the current head as last node of # remaining linked list head.next.next = head # Update next of current head to NULL head.next = None # Return the reversed linked list return rest def printList(node): while node is not None: print(f" {node.data}", end='') node = node.next print() if __name__ == "__main__": # Create a hard-coded linked list: # 1 -> 2 -> 3 -> 4 -> 5 head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5) print("Given Linked List:", end='') printList(head) head = reverseList(head) print("\nReversed Linked List:", end='') printList(head) // Recursive C# program to reverse a linked list using System; class Node { public int Data; public Node Next; public Node(int newData) { Data = newData; Next = null; } } class GfG { // Given the head of a list, reverse the list // and return the head of reversed list static Node ReverseList(Node head) { if (head == null || head.Next == null) return head; // reverse the rest of linked list and // put the first element at the end Node rest = ReverseList(head.Next); // Make the current head as last node // of remaining linked list head.Next.Next = head; // Update next of current head to NULL head.Next = null; // Return the reversed linked list return rest; } // This function prints the contents // of the linked list starting from the head static void PrintList(Node node) { while (node != null) { Console.Write(" " + node.Data); node = node.Next; } Console.WriteLine(); } static void Main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.Next = new Node(2); head.Next.Next = new Node(3); head.Next.Next.Next = new Node(4); head.Next.Next.Next.Next = new Node(5); Console.Write("Given Linked List:"); PrintList(head); head = ReverseList(head); Console.Write("\nReversed Linked List:"); PrintList(head); } } // Recursive javascript program to reverse a linked list class Node { constructor(new_data) { this.data = new_data; this.next = null; } } // Given the head of a list, reverse the list // and return the head of reversed list function reverseList(head) { if (head === null || head.next === null) return head; // reverse the rest of linked list and // put the first element at the end let rest = reverseList(head.next); // Make the current head as last node of // remaining linked list head.next.next = head; // Update next of current head to NULL head.next = null; // Return the reversed linked list return rest; } function printList(node) { while (node !== null) { console.log(` ${node.data}`); node = node.next; } console.log(); } // Driver Code // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); console.log("Given Linked List:"); printList(head); head = reverseList(head); console.log("\nReversed Linked List:"); printList(head); OutputGiven Linked List: 1 2 3 4 5 Reversed Linked List: 5 4 3 2 1
[Alternate Approach - 2] Using Stack - O(n) Time and O(n) Space
The idea is to traverse the linked list and push all nodes except the last node into the stack. Make the last node as the new head of the reversed linked list. Now, start popping the element and append each node to the reversed Linked List. Finally, return the head of the reversed linked list.
Follow the steps below to solve the problem:
- Push all the nodes(values and address) except the last node in the stack.
- Once the nodes are pushed, update the Head pointer to the last node.
- Start popping the nodes and push them at the end of the linked list in the same order until the stack is empty.
- Update the next pointer of last node in the stack by NULL.
C++ // C++ program to reverse linked list using Stack #include <bits/stdc++.h> using namespace std; class Node { public: int data; Node* next; Node(int new_data) { data = new_data; next = nullptr; } }; // Function to reverse the linked list Node* reverseList(Node* head) { // Create a stack to store the nodes stack<Node*> s; Node* temp = head; // Push all nodes except the last node into stack while (temp->next != NULL) { s.push(temp); temp = temp->next; } // Make the last node as new head of the linked list head = temp; // Pop all the nodes and append to the linked list while (!s.empty()) { // append the top value of stack in list temp->next = s.top(); // Pop the value from stack s.pop(); // move to the next node in the list temp = temp->next; } // Update the next pointer of last node of stack to NULL temp->next = NULL; return head; } void printList(Node* node) { while (node != nullptr) { cout << " " << node->data; node = node->next; } } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node* head = new Node(1); head->next = new Node(2); head->next->next = new Node(3); head->next->next->next = new Node(4); head->next->next->next->next = new Node(5); cout << "Given Linked List:"; printList(head); head = reverseList(head); cout << "\nReversed Linked List:"; printList(head); return 0; } // C program to reverse linked list using Stack #include <stdio.h> struct Node { int data; struct Node* next; }; // Function to create a new node struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; } // Function to reverse the linked list struct Node* reverseList(struct Node* head) { // Create a stack to store the nodes struct Node* stack[100000]; int top = -1; struct Node* temp = head; // Push all nodes except the last node into stack while (temp != NULL) { stack[++top] = temp; temp = temp->next; } // Make the last node as new head of the linked list if (top >= 0) { head = stack[top]; temp = head; // Pop all the nodes and append to the linked list while (top > 0) { // append the top value of stack in list and // pop the top value by decrementing top by 1 temp->next = stack[--top]; // move to the next node in the list temp = temp->next; } // Update the next pointer of last node of stack to NULL temp->next = NULL; } return head; } void printList(struct Node* node) { while (node != NULL) { printf(" %d", node->data); node = node->next; } printf("\n"); } int main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 struct Node* head = createNode(1); head->next = createNode(2); head->next->next = createNode(3); head->next->next->next = createNode(4); head->next->next->next->next = createNode(5); printf("Given Linked List:"); printList(head); head = reverseList(head); printf("\nReversed Linked List:"); printList(head); return 0; } // Java program to reverse linked list using Stack import java.util.Stack; class Node { int data; Node next; Node(int new_data) { data = new_data; next = null; } } class GfG { // Function to reverse the linked list static Node reverseList(Node head) { // Create a stack to store the nodes Stack<Node> stack = new Stack<>(); Node temp = head; // Push all nodes except the last node into stack while (temp != null) { stack.push(temp); temp = temp.next; } // Make the last node as new head of the linked list if (!stack.isEmpty()) { head = stack.pop(); temp = head; // Pop all the nodes and append to the linked list while (!stack.isEmpty()) { // append the top value of stack in list temp.next = stack.pop(); // move to the next node in the list temp = temp.next; } // Update the next pointer of last node // of stack to NULL temp.next = null; } return head; } // This function prints the contents // of the linked list starting from the head static void printList(Node node) { while (node != null) { System.out.print(" " + node.data); node = node.next; } System.out.println(); } public static void main(String[] args) { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); System.out.print("Given Linked List:"); printList(head); head = reverseList(head); System.out.print("\nReversed Linked List:"); printList(head); } } # Python program to reverse linked list using Stack class Node: def __init__(self, new_data): self.data = new_data self.next = None def reverseList(head): # Create a stack to store the nodes stack = [] temp = head # Push all nodes except the last node into stack while temp.next is not None: stack.append(temp) temp = temp.next # Make the last node as new head of the linked list head = temp # Pop all the nodes and append to the linked list while stack: # append the top value of stack in list temp.next = stack.pop() # move to the next node in the list temp = temp.next # Update the next pointer of last node # of stack to None temp.next = None return head def printList(node): while node is not None: print(f" {node.data}", end="") node = node.next print() # Create a hard-coded linked list: # 1 -> 2 -> 3 -> 4 -> 5 head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5) print("Given Linked List:", end="") printList(head) head = reverseList(head) print("Reversed Linked List:", end="") printList(head) // C# program to reverse linked list using stack using System; using System.Collections.Generic; class Node { public int Data; public Node Next; public Node(int newData) { Data = newData; Next = null; } } class GfG { // Function to reverse the linked list static Node ReverseList(Node head) { // Create a stack to store the nodes Stack<Node> stack = new Stack<Node>(); Node temp = head; // Push all nodes except the last node into stack while (temp.Next != null) { stack.Push(temp); temp = temp.Next; } // Make the last node as new head of the linked list head = temp; // Pop all the nodes and append to the linked list while (stack.Count > 0) { // append the top value of stack in list temp.Next = stack.Pop(); // move to the next node in the list temp = temp.Next; } // Update the next pointer of last node of stack to null temp.Next = null; return head; } static void PrintList(Node node) { while (node != null) { Console.Write(" " + node.Data); node = node.Next; } Console.WriteLine(); } static void Main() { // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.Next = new Node(2); head.Next.Next = new Node(3); head.Next.Next.Next = new Node(4); head.Next.Next.Next.Next = new Node(5); Console.Write("Given Linked List:"); PrintList(head); head = ReverseList(head); Console.Write("\nReversed Linked List:"); PrintList(head); } } // JavaScript program to reverse linked list using Stack class Node { constructor(newData) { this.data = newData; this.next = null; } } // Function to reverse the linked list function reverseList(head) { // Create a stack to store the nodes let stack = []; let temp = head; // Push all nodes except the last node into stack while (temp.next !== null) { stack.push(temp); temp = temp.next; } // Make the last node as new head of the Linked List head = temp; // Pop all the nodes and append to the linked list while (stack.length > 0) { // append the top value of stack in list temp.next = stack.pop(); // move to the next node in the list temp = temp.next; } // Update the next pointer of last node of stack to null temp.next = null; return head; } function printList(node) { while (node !== null) { console.log(" " + node.data); node = node.next; } console.log(); } // Create a hard-coded linked list: // 1 -> 2 -> 3 -> 4 -> 5 let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); console.log("Given Linked List:"); printList(head); // Function call to return the reversed list head = reverseList(head); console.log("\nReversed Linked List:"); printList(head); OutputGiven Linked List: 1 2 3 4 5 Reversed Linked List: 5 4 3 2 1
Similar Reads
Linked List Data Structure A linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
2 min read
Basic Terminologies of Linked List Linked List is a linear data structure, in which elements are not stored at a contiguous location, rather they are linked using pointers. Linked List forms a series of connected nodes, where each node stores the data and the address of the next node.Node Structure: A node in a linked list typically
2 min read
Introduction to Linked List - Data Structure and Algorithm Tutorials Linked List is basically chains of nodes where each node contains information such as data and a pointer to the next node in the chain. It is a popular data structure with a wide range of real-world applications. Unlike Arrays, Linked List elements are not stored at a contiguous location. In the lin
9 min read
Applications, Advantages and Disadvantages of Linked List A Linked List is a linear data structure that is used to store a collection of data with the help of nodes. Please remember the following points before moving forward.The consecutive elements are connected by pointers / references.The last node of the linked list points to null.The entry point of a
4 min read
Linked List vs Array Array: Arrays store elements in contiguous memory locations, resulting in easily calculable addresses for the elements stored and this allows faster access to an element at a specific index.Data storage scheme of an arrayLinked List: Linked lists are less rigid in their storage structure and element
2 min read
Types of Linked List
Basic Operations on Linked List
Insertion in Linked ListInsertion in a linked list involves adding a new node at a specified position in the list. There are several types of insertion based on the position where the new node is to be added:At the front of the linked list Before a given node.After a given node.At a specific position.At the end of the link
4 min read
Search an element in a Linked List (Iterative and Recursive)Given a linked list and a key, the task is to check if key is present in the linked list or not. Examples:Input: 14 -> 21 -> 11 -> 30 -> 10, key = 14Output: YesExplanation: 14 is present in the linked list.Input: 6 -> 21 -> 17 -> 30 -> 10 -> 8, key = 13Output: NoExplanatio
12 min read
Find Length of a Linked List (Iterative and Recursive)Given a Singly Linked List, the task is to find the Length of the Linked List.Examples:Input: LinkedList = 1->3->1->2->1Output: 5Explanation: The linked list has 5 nodes.Input: LinkedList = 2->4->1->9->5->3->6Output: 7 Explanation: The linked list has 7 nodes.Input: Lin
11 min read
Reverse a Linked ListGiven a linked list, the task is to reverse the linked list by changing the links between nodes.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> NULLOutput: head: 4 -> 3 -> 2 -> 1 -> NULLExplanation: Reversed Linked List: Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULLOut
15+ min read
Deletion in Linked ListDeleting a node in a Linked List is an important operation and can be done in three main ways: removing the first node, removing a node in the middle, or removing the last node.In this article, we will explore deletion operation on Linked List for all the above scenarios. Types of Deletion in Linked
3 min read
Delete a Linked List node at a given positionGiven a singly linked list and a position (1-based indexing), the task is to delete a linked list node at the given position.Note: Position will be valid (i.e, 1 <= position <= linked list length)Example: Input: position = 2, Linked List = 8->2->3->1->7Output: Linked List = 8->3
8 min read
Write a function to delete a Linked ListGiven a linked list, the task is to delete the linked list completely.Examples:Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULLOutput: NULLExplanation: Linked List is Deleted.Input: head: 1 -> 12 -> 1 -> 4 -> 1 -> NULLOutput: NULLExplanation: Linked List is Deleted.Table of C
9 min read
Write a function to get Nth node in a Linked ListGiven a LinkedList and an index (1-based). The task is to find the data value stored in the node at that kth position. If no such node exists whose index is k then return -1.Example:Â Input: 1->10->30->14, index = 2Output: 10Explanation: The node value at index 2 is 10 Input: 1->32->12
11 min read
Program for Nth node from the end of a Linked ListGiven a Linked List of M nodes and a number N, find the value at the Nth node from the end of the Linked List. If there is no Nth node from the end, print -1.Examples:Input: 1 -> 2 -> 3 -> 4, N = 3Output: 2Explanation: Node 2 is the third node from the end of the linked list.Input: 35 ->
14 min read
Top 50 Problems on Linked List Data Structure asked in SDE Interviews A Linked List is a linear data structure that looks like a chain of nodes, where each node is a different element. Unlike Arrays, Linked List elements are not stored at a contiguous location. Here is the collection of the Top 50 list of frequently asked interview questions on Linked Lists. Problems
3 min read