kth from the end of a Linked List (original) (raw)

Last Updated : 22 Mar, 2026

Given a Linked List and a number **k, find the value at the kth node from the end of the Linked List. If there is no Nth node from the end, print -1.

**Examples:

**Input: head=1 -> 2 -> 3 -> 4, k= 3
**Output: 2
**Explanation: Node 2 is the third node from the end of the linked list.

**Input: head=35 -> 15 -> 4 -> 20, k = 5
**Output: -1
**Explanation: length of linked list is less then k so -1.

Try It Yourself

Table of Content

• [Naive Approach] Length-Based Traversal - O(n) Time and O(1) Space
• [Expected Approach] Using Two Pointers(Slow and fast) - One Pass - O(n) Time and O(1) Space

**[Naive Approach] Length-Based Traversal - O(n) Time and O(1) Space

The idea is to count the number of nodes in linked list in the first pass, say **len. In the second pass, return the ****(len - k + 1)th** nodes from beginning of the Linked List.

C++14 `

#include using namespace std;

// Link list node struct Node { int data; Node* next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = nullptr;
}

};

// Function to find the kth node from the last of a linked list int findKthFromLast(Node* head, int k) { int len = 0, i;

// Pointer to store the copy of head
Node* temp = head;

// Count the number of nodes in Linked List
while (temp != NULL) {
    temp = temp->next;
    len++;
}

// Check if value of k is not more than length of the linked list
if (len < k)
    return -1;

temp = head;

// Get the (len - k + 1)th node from the beginning
for (i = 1; i < len - k + 1; i++)
    temp = temp->next;

return temp->data;

}

int main() { // Create a hard-coded linked list: 35 -> 15 -> 4 -> 20 Node* head = new Node(35); head->next = new Node(15); head->next->next = new Node(4); head->next->next->next = new Node(20);

// Function Call to find the 4th node from end
cout << findKthFromLast(head, 4);
return 0;

}

C

#include <stdio.h> #include <stdlib.h>

// Link list node struct Node { int data; struct Node* next; };

// Function to create a new node with given data struct Node* newNode(int new_data) { struct Node* node = (struct Node*)malloc(sizeof(struct Node)); node->data = new_data; node->next = NULL; return node; }

// Function to find the kth node from the last of a linked list int findKthFromLast(struct Node* head, int k) { int len = 0, i;

// Pointer to store the copy of head
struct Node* temp = head;

// Count the number of nodes in Linked List
while (temp != NULL) {
    temp = temp->next;
    len++;
}

// Check if value of k is not more than length of the linked list
if (len < k)
    return -1;

temp = head;

// Get the (len - k + 1)th node from the beginning
for (i = 1; i < len - k + 1; i++)
    temp = temp->next;

return temp->data;

}

int main() { // Create a hard-coded linked list: 35 -> 15 -> 4 -> 20 struct Node* head = newNode(35); head->next = newNode(15); head->next->next = newNode(4); head->next->next->next = newNode(20);

// Function Call to find the 4th node from end
printf("%d\n", findKthFromLast(head, 4));
return 0;

}

Java

class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = null;
}

}

public class Main {

// Function to find the kth node from the last of a linked list
static int findKthFromLast(Node head, int k) {
    int len = 0;

    // Pointer to store the copy of head
    Node temp = head;

    // Count the number of nodes in Linked List
    while (temp != null) {
        temp = temp.next;
        len++;
    }

    // Check if value of k is not more than length of the linked list
    if (len < k)
        return -1;

    temp = head;

    // Get the (len - k + 1)th node from the beginning
    for (int i = 1; i < len - k + 1; i++)
        temp = temp.next;

    return temp.data;
}

public static void main(String[] args) {
    // Create a hard-coded linked list: 35 -> 15 -> 4 -> 20
    Node head = new Node(35);
    head.next = new Node(15);
    head.next.next = new Node(4);
    head.next.next.next = new Node(20);

    // Function Call to find the 4th node from end
    System.out.println(findKthFromLast(head, 4));
}

}

Python

class Node: def init(self, new_data): self.data = new_data self.next = None

Function to find the kth node from the last of a linked list

def findKthFromLast(head, k): length = 0 temp = head

# Count the number of nodes in Linked List
while temp:
    temp = temp.next
    length += 1

# Check if value of k is not more than length of the linked list
if length < k:
    return -1

temp = head

# Get the (len - k + 1)th node from the beginning
for _ in range(1, length - k + 1):
    temp = temp.next

return temp.data

if name=="main": # Create a hard-coded linked list: 35 -> 15 -> 4 -> 20 head = Node(35) head.next = Node(15) head.next.next = Node(4) head.next.next.next = Node(20)

# Function Call to find the 4th node from end
print(findKthFromLast(head, 4))

C#

using System;

class Node { public int data; public Node next;

// Constructor to initialize a new node with data
public Node(int new_data) {
    data = new_data;
    next = null;
}

}

class Program { // Function to find the kth node from the last of a linked list static int findKthFromLast(Node head, int k) { int len = 0;

    // Pointer to store the copy of head
    Node temp = head;

    // Count the number of nodes in Linked List
    while (temp != null) {
        temp = temp.next;
        len++;
    }

    // Check if value of k is not more than length of the linked list
    if (len < k)
        return -1;

    temp = head;

    // Get the (len - k + 1)th node from the beginning
    for (int i = 1; i < len - k + 1; i++)
        temp = temp.next;

    return temp.data;
}

static void Main(string[] args) {
    // Create a hard-coded linked list: 35 -> 15 -> 4 -> 20
    Node head = new Node(35);
    head.next = new Node(15);
    head.next.next = new Node(4);
    head.next.next.next = new Node(20);

    // Function Call to find the 4th node from end
    Console.WriteLine(findKthFromLast(head, 4));
}

}

JavaScript

class Node { constructor(new_data) { this.data = new_data; this.next = null; } }

// Function to find the kth node from the last of a linked list function findKthFromLast(head, k) { let len = 0; let temp = head;

// Count the number of nodes in Linked List
while (temp !== null) {
    temp = temp.next;
    len++;
}

// Check if value of k is not more than length of the linked list
if (len < k) return -1;

temp = head;

// Get the (len - k + 1)th node from the beginning
for (let i = 1; i < len - k + 1; i++)
    temp = temp.next;

return temp.data;

} // Driver Code // Create a hard-coded linked list: 35 -> 15 -> 4 -> 20 let head = new Node(35); head.next = new Node(15); head.next.next = new Node(4); head.next.next.next = new Node(20);

// Function Call to find the 4th node from end console.log(findKthFromLast(head, 4));

`

**Time complexity: O(n) where nis number of nodes in the linked list
**Auxiliary Space: O(1)

[Expected Approach] Using Two Pointers(Slow and fast) - One Pass - O(n) Time and O(1) Space

The idea is to maintain two pointers, say **main_ptr and **ref_ptr point to the head of Linked List and move *ref_ptr to the Nth node from the head to ensure that the distance between main_ptr and ref_ptr is ****(k - 1)**. Now, move both the pointers simultaneously until ref_ptr reaches the last node. Since the distance between main_ptr and ref_ptr is (k - 1), so when ref_ptr will reach the last node, main_ptr will reach k**th* node from the end of Linked List. Return the value of node pointed by main_ptr.

Below image is a dry run of the above approach:

Follow the given steps to solve the problem:

• Maintain two pointers **main_ptr and **ref_ptr
• Move ref_ptr to the kth node from the start
• Now move both main_ptr and ref_ptr, until the ref_ptr reaches the last node
• Now return the data of the main_ptr, as it is at the kth node from the end C++ `

#include using namespace std;

// Link list node struct Node { int data; Node* next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = nullptr;
}

};

// Function to find kth node from the end of linked list int kthFromEnd(Node* head, int k) {

// Create two pointers main_ptr and ref_ptr
// initially pointing to head.
Node* main_ptr = head;
Node* ref_ptr = head;

// Move ref_ptr to the k-th node from beginning.
for (int i = 1; i < k; i++) {
    ref_ptr = ref_ptr->next;

    // If the ref_ptr reaches NULL, then it means 
    // k > length of linked list
    if (ref_ptr == NULL) {
        return -1;
    }
}

// Move ref_ptr and main_ptr by one node until
// ref_ptr reaches last node of the list.
while (ref_ptr->next != NULL) {
    ref_ptr = ref_ptr->next;
    main_ptr = main_ptr->next;
}

return main_ptr->data;

}

int main() {

// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node* head = new Node(35);
head->next = new Node(15);
head->next->next = new Node(4);
head->next->next->next = new Node(20);

// Function Call to find the 4th node from end
cout << kthFromEnd(head, 4);
return 0;

}

C

#include <stdio.h> #include <stdlib.h>

// Link list node struct Node { int data; struct Node* next; };

// Function to create a new node with given data struct Node* newNode(int new_data) { struct Node* node = (struct Node*)malloc(sizeof(struct Node)); node->data = new_data; node->next = NULL; return node; }

// Function to find kth node from the end of linked list int kthFromEnd(struct Node* head, int k) {

// Create two pointers main_ptr and ref_ptr
// initially pointing to head.
struct Node* main_ptr = head;
struct Node* ref_ptr = head;

// Move ref_ptr to the k-th node from beginning.
for (int i = 1; i < k; i++) {
    ref_ptr = ref_ptr->next;

    // If the ref_ptr reaches NULL, then it means 
    // k > length of linked list
    if (ref_ptr == NULL) {
        return -1;
    }
}

// Move ref_ptr and main_ptr by one node until
// ref_ptr reaches last node of the list.
while (ref_ptr->next != NULL) {
    ref_ptr = ref_ptr->next;
    main_ptr = main_ptr->next;
}

return main_ptr->data;

}

int main() { // Create a hard-coded linked list: // 35 -> 15 -> 4 -> 20 struct Node* head = newNode(35); head->next = newNode(15); head->next->next = newNode(4); head->next->next->next = newNode(20);

// Function Call to find the 4th node from end
printf("%d\n", kthFromEnd(head, 4));

return 0;

}

Java

class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = null;
}

}

public class Main {

// Function to find kth node from the end of linked list
static int kthFromEnd(Node head, int k) {

    // Create two pointers main_ptr and ref_ptr
    // initially pointing to head.
    Node main_ptr = head;
    Node ref_ptr = head;

    // Move ref_ptr to the k-th node from beginning.
    for (int i = 1; i < k; i++) {
        ref_ptr = ref_ptr.next;

        // If the ref_ptr reaches NULL, then it means 
        // k > length of linked list
        if (ref_ptr == null) {
            return -1;
        }
    }

    // Move ref_ptr and main_ptr by one node until
    // ref_ptr reaches last node of the list.
    while (ref_ptr.next != null) {
        ref_ptr = ref_ptr.next;
        main_ptr = main_ptr.next;
    }

    return main_ptr.data;
}

public static void main(String[] args) {

    // Create a hard-coded linked list:
    // 35 -> 15 -> 4 -> 20
    Node head = new Node(35);
    head.next = new Node(15);
    head.next.next = new Node(4);
    head.next.next.next = new Node(20);

    // Function Call to find the 4th node from end
    System.out.println(kthFromEnd(head, 4));
}

}

Python

class Node: def init(self, new_data): self.data = new_data self.next = None

Function to find kth node from the end of linked list

def kthFromEnd(head, k):

# Create two pointers main_ptr and ref_ptr
# initially pointing to head.
main_ptr = head
ref_ptr = head

# Move ref_ptr to the k-th node from beginning.
for _ in range(1, k):
    ref_ptr = ref_ptr.next

    # If the ref_ptr reaches None, then it means 
    # k > length of linked list
    if ref_ptr is None:
        return -1

# Move ref_ptr and main_ptr by one node until
# ref_ptr reaches last node of the list.
while ref_ptr.next is not None:
    ref_ptr = ref_ptr.next
    main_ptr = main_ptr.next

return main_ptr.data

if name == "main": # Create a hard-coded linked list: # 35 -> 15 -> 4 -> 20 head = Node(35) head.next = Node(15) head.next.next = Node(4) head.next.next.next = Node(20)

# Function Call to find the 4th node from end
print(kthFromEnd(head, 4))

C#

using System;

class Node { public int data; public Node next;

// Constructor to initialize a new node with data
public Node(int new_data) {
    data = new_data;
    next = null;
}

}

class Program {

// Function to find kth node from the end of linked list
static int KthFromEnd(Node head, int k) {

    // Create two pointers main_ptr and ref_ptr
    // initially pointing to head.
    Node main_ptr = head;
    Node ref_ptr = head;

    // Move ref_ptr to the k-th node from beginning.
    for (int i = 1; i < k; i++) {
        ref_ptr = ref_ptr.next;

        // If the ref_ptr reaches NULL, then it means 
        // k > length of linked list
        if (ref_ptr == null) {
            return -1;
        }
    }

    // Move ref_ptr and main_ptr by one node until
    // ref_ptr reaches last node of the list.
    while (ref_ptr.next != null) {
        ref_ptr = ref_ptr.next;
        main_ptr = main_ptr.next;
    }

    return main_ptr.data;
}

static void Main() {
    // Create a hard-coded linked list:
    // 35 -> 15 -> 4 -> 20
    Node head = new Node(35);
    head.next = new Node(15);
    head.next.next = new Node(4);
    head.next.next.next = new Node(20);

    // Function Call to find the 4th node from end
    Console.WriteLine(KthFromEnd(head, 4));
}

}

JavaScript

class Node { constructor(new_data) { this.data = new_data; this.next = null; } }

// Function to find kth node from the end of linked list function kthFromEnd(head, k) {

// Create two pointers main_ptr and ref_ptr
// initially pointing to head.
let main_ptr = head;
let ref_ptr = head;

// Move ref_ptr to the k-th node from beginning.
for (let i = 1; i < k; i++) {
    ref_ptr = ref_ptr.next;

    // If the ref_ptr reaches null, then it means 
    // k > length of linked list
    if (ref_ptr === null) {
        return -1;
    }
}

// Move ref_ptr and main_ptr by one node until
// ref_ptr reaches last node of the list.
while (ref_ptr.next !== null) {
    ref_ptr = ref_ptr.next;
    main_ptr = main_ptr.next;
}

return main_ptr.data;

}

// Create a hard-coded linked list: // 35 -> 15 -> 4 -> 20 let head = new Node(35); head.next = new Node(15); head.next.next = new Node(4); head.next.next.next = new Node(20);

// Function Call to find the 4th node from end console.log(kthFromEnd(head, 4));

`

**Time Complexity: O(n) where nis number of nodes the linked list
**Auxiliary Space: O(1)