# Remove Nth Node From End of List Leetcode Solution

Difficulty Level Medium

## Problem Statement

The Remove Nth Node From End of List Leetcode Solution – states that you are given the head of a linked list and you need to remove the nth node from the end of this list.

After deleting this node, return the head of the modified list.

## Example:     `Input: head = [1,2,3,4,5], n = 2`
`Output: [1,2,3,5]`

Explanation:

`Input: head = , n = 1`
`Output: []`

Explanation:

• We need to remove the end node of the list.
• After removing the node, we have an empty list.

## Approach

### Idea:

1. The main idea to solve this problem is to use three variables that store the node’s addresses.
• curr = It will store the current node’s address used to iterate in the linked list.
• start = It will store the node’s address that will be deleted (nth node from the end of the list).
• prev = It will store the previous node’s address of the node’s start.
2. Note that, the distance between the deleting node and head of the linked list is m-n and the distance between deleting node and end of the linked list is n, where m = length of linked list.
3. The above observation suggests that start the curr variable from the head of the linked list and decrement n each time as we move forward in the linked list. As soon as we have n as a non-positive value, initialize the start variable with the address of the head of the linked list and increment the start variable as well as the prev variable each time when n is non-positive.
4. Step 3 works efficiently since whatever the distance curr variable covers after n becomes non-positive, will be equal to the distance covered by the start variable from the head of the linked list which is m-n. Hence, we’ll end up with the nth node from the end’s address stored in the start variable.
5. Delete the node contained in the start variable, by assigning prev next node address as the start next address.
6. Check code for better understanding.

## Code

### Remove Nth Node From End of List Leetcode C++ Solution:

```class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode *prev = nullptr,*curr = head,*start = nullptr;
while(curr!=nullptr){
n--;
curr = curr->next;
if(n<=0){
if(start==nullptr){
}
else{
prev = start;
start = start->next;
}
}
}
if(prev==nullptr){
return start->next;
}
prev->next = start->next;
}
};```

### Remove Nth Node From End of List Leetcode Java Solution:

```class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode prev = null;
ListNode start = null;
while(curr!=null){
n = n - 1;
curr = curr.next;
if(n<=0){
if(start==null){
}
else{
prev = start;
start = start.next;
}
}
}
if(prev==null){
return start.next;
}
prev.next = start.next;
}
}```

## Complexity Analysis for Remove Nth Node From End of List Leetcode Solution

### Time Complexity

The time complexity of the above code is O(N), where N = length of the linked list since we’re iterating for the entire linked list one time.

### Space Complexity

The space complexity of the above code O(1) since we’re using constant extra space.

Translate »