Find kth node from Middle towards Head of a Linked List

Given a Linked List and a number K. The task is to print the value of the K-th node from the middle towards the beginning of the List. If no such element exists, then print “-1”.

Note: Position of middle node is: (n/2)+1, where n is the total number of nodes in the list.

Examples:

Input :  List is 1->2->3->4->5->6->7
         K= 2 
Output : 2

Input :  list is 7->8->9->10->11->12
         K = 3
Output : 7

Traverse the List from beginning to end and count the total number of nodes. Now, suppose n is the total number of nodes in the List. Therefore, the middle node will be at the position (n/2)+1. Now, the task remains to print the node at (n/2 + 1 – k)th position from the head of the List.

Below is the implementation of the above idea:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find kth node from middle
// towards Head of the Linked List
  
#include <bits/stdc++.h>
  
using namespace std;
  
// Linked list node
struct Node {
    int data;
    struct Node* next;
};
  
/* Given a reference (pointer to  
   pointer) to the head of a list 
   and an int, push a new node on 
   the front of the list. */
void push(struct Node** head_ref,
          int new_data)
{
    struct Node* new_node = new Node;
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
  
// Function to count number of nodes
int getCount(struct Node* head)
{
    int count = 0; // Initialize count
    struct Node* current = head; // Initialize current
    while (current != NULL) {
        count++;
        current = current->next;
    }
    return count;
}
  
// Function to get the kth node from the mid
// towards begin of the linked list
int printKthfrommid(struct Node* head_ref, int k)
{
    // Get the count of total number of
    // nodes in the linked list
    int n = getCount(head_ref);
  
    int reqNode = ((n / 2 + 1) - k);
  
    // If no such node exists, return -1
    if (reqNode <= 0) {
        return -1;
    }
  
    // Find node at position reqNode
    else {
        struct Node* current = head_ref;
  
        // the index of the
        // node we're currently
        // looking at
        int count = 1;
        while (current != NULL) {
            if (count == reqNode)
                return (current->data);
            count++;
            current = current->next;
        }
    }
}
  
// Driver code
int main()
{
    // start with empty list
    struct Node* head = NULL;
    int k = 2;
  
    // create linked list
    // 1->2->3->4->5->6->7
    push(&head, 7);
    push(&head, 6);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, 2);
    push(&head, 1);
  
    cout << printKthfrommid(head, 2);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Kth node from mid
// of a linked list in single traversal
  
// Linked list node
class Node
{
    int data;
    Node next;
    Node(int d)
    {
        this.data = d;
        this.next = null;
    }
}
  
class LinkedList
{
    Node start;
    LinkedList()
    {
        start = null;
    }
      
    // Function to push node at head
    public void push(int data)
    
        if(this.start == null)
        {
            Node temp = new Node(data);
            this.start = temp;
        }
        else
        {
            Node temp = new Node(data);
            temp.next = this.start;
            this.start = temp;
        }
    }
      
    //method to get the count of node
    public int getCount(Node start)
    {
        Node temp = start;
        int cnt = 0;
        while(temp != null)
        {
            temp = temp.next;
            cnt++;
        }
        return cnt;
    }
      
    // Function to get the kth node from the mid
    // towards begin of the linked list
    public int printKthfromid(Node start, int k)
    
        // Get the count of total number of
        // nodes in the linked list
        int n = getCount(start);
        int reqNode = ((n + 1) / 2) - k;
  
        // If no such node exists, return -1
        if(reqNode <= 0)
            return -1;
        else
        {
            Node current = start;
            int count = 1,ans = 0;
            while (current != null
            
                if (count == reqNode) 
                {
                    ans = current.data;
                    break
                }
                count++; 
                current = current.next; 
            }
            return ans;
        }
    }
      
    // Driver code
    public static void main(String[] args) 
    {
    // create linked list
        // 1->2->3->4->5->6->7 
    LinkedList ll = new LinkedList();
        ll.push(7);
        ll.push(6);
        ll.push(5);
        ll.push(4);
        ll.push(3);
        ll.push(2);
        ll.push(1);
        System.out.println(ll.printKthfromid(ll.start, 2));
    }
}
  
// This Code is contributed by Adarsh_Verma

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find Kth node from mid
// of a linked list in single traversal
using System;
  
// Linked list node
public class Node
{
    public int data;
    public Node next;
    public Node(int d)
    {
        this.data = d;
        this.next = null;
    }
}
  
public class LinkedList
{
    Node start;
    LinkedList()
    {
        start = null;
    }
      
    // Function to push node at head
    public void push(int data)
    
        if(this.start == null)
        {
            Node temp = new Node(data);
            this.start = temp;
        }
        else
        {
            Node temp = new Node(data);
            temp.next = this.start;
            this.start = temp;
        }
    }
      
    //method to get the count of node
    public int getCount(Node start)
    {
        Node temp = start;
        int cnt = 0;
        while(temp != null)
        {
            temp = temp.next;
            cnt++;
        }
        return cnt;
    }
      
    // Function to get the kth node from the mid
    // towards begin of the linked list
    public int printKthfromid(Node start, int k)
    
        // Get the count of total number of
        // nodes in the linked list
        int n = getCount(start);
        int reqNode = ((n + 1) / 2) - k;
  
        // If no such node exists, return -1
        if(reqNode <= 0)
            return -1;
        else
        {
            Node current = start;
            int count = 1,ans = 0;
            while (current != null
            
                if (count == reqNode) 
                {
                    ans = current.data;
                    break
                }
                count++; 
                current = current.next; 
            }
            return ans;
        }
    }
      
    // Driver code
    public static void Main(String[] args) 
    {
        // create linked list
        // 1->2->3->4->5->6->7 
        LinkedList ll = new LinkedList();
        ll.push(7);
        ll.push(6);
        ll.push(5);
        ll.push(4);
        ll.push(3);
        ll.push(2);
        ll.push(1);
        Console.WriteLine(ll.printKthfromid(ll.start, 2));
    }
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

2

Time Complexity: O(n), where n is the length of the list.
Auxiliary Space: O(1)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Adarsh_Verma, Rajput-Ji



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.