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: The position of the 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
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++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
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;
}
int getCount( struct Node* head)
{
int count = 0;
struct Node* current = head;
while (current != NULL) {
count++;
current = current->next;
}
return count;
}
int printKthfrommid( struct Node* head_ref, int k)
{
int n = getCount(head_ref);
int reqNode = ((n / 2 + 1) - k);
if (reqNode <= 0) {
return -1;
}
else {
struct Node* current = head_ref;
int count = 1;
while (current != NULL) {
if (count == reqNode)
return (current->data);
count++;
current = current->next;
}
}
}
int main()
{
struct Node* head = NULL;
int k = 2;
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;
}
|
Java
class Node
{
int data;
Node next;
Node( int d)
{
this .data = d;
this .next = null ;
}
}
class LinkedList
{
Node start;
LinkedList()
{
start = null ;
}
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;
}
}
public int getCount(Node start)
{
Node temp = start;
int cnt = 0 ;
while (temp != null )
{
temp = temp.next;
cnt++;
}
return cnt;
}
public int printKthfromid(Node start, int k)
{
int n = getCount(start);
int reqNode = ((n + 1 ) / 2 ) - k;
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;
}
}
public static void main(String[] args)
{
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 ));
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
def push(head, data):
if not head:
return Node(data)
new_node = Node(data)
new_node. next = head
head = new_node
return head
def getCount(head):
count = 0
current = head
while (current ):
count = count + 1
current = current. next
return count
def printKthfrommid(head_ref, k):
n = getCount(head_ref)
reqNode = int ((n / 2 + 1 ) - k)
if (reqNode < = 0 ) :
return - 1
else :
current = head_ref
count = 1
while (current) :
if (count = = reqNode):
return (current.data)
count = count + 1
current = current. next
if __name__ = = '__main__' :
head = None
k = 2
head = push(head, 7 )
head = push(head, 6 )
head = push(head, 5 )
head = push(head, 4 )
head = push(head, 3 )
head = push(head, 2 )
head = push(head, 1 )
print (printKthfrommid(head, 2 ))
|
C#
using System;
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 ;
}
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;
}
}
public int getCount(Node start)
{
Node temp = start;
int cnt = 0;
while (temp != null )
{
temp = temp.next;
cnt++;
}
return cnt;
}
public int printKthfromid(Node start, int k)
{
int n = getCount(start);
int reqNode = ((n + 1) / 2) - k;
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;
}
}
public static void Main(String[] args)
{
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));
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
var start = null ;
function push(data) {
if ( this .start == null )
{
temp = new Node(data);
this .start = temp;
}
else
{
temp = new Node(data);
temp.next = this .start;
this .start = temp;
}
}
function getCount( start) {
temp = start;
var cnt = 0;
while (temp != null ) {
temp = temp.next;
cnt++;
}
return cnt;
}
function printKthfromid( start , k)
{
var n = getCount(start);
var reqNode = ((n + 1) / 2) - k;
if (reqNode <= 0)
return -1;
else {
current = start;
var count = 1, ans = 0;
while (current != null ) {
if (count == reqNode) {
ans = current.data;
break ;
}
count++;
current = current.next;
}
return ans;
}
}
push(7);
push(6);
push(5);
push(4);
push(3);
push(2);
push(1);
document.write(printKthfromid(start, 2));
</script>
|
Complexity Analysis:
- Time Complexity: O(n), where n is the length of the list.
- Auxiliary Space: O(1)
Method 2 :
This method focuses on finding the K-th node from the middle towards the beginning of the List using two pointers.
Prerequisite: two pointers method in https://www.geeksforgeeks.org/write-a-c-function-to-print-the-middle-of-the-linked-list/
Traverse linked list using two pointers named as slow and fast. Move the fast pointer B times if it reaches the end, then no answer exists print “-1” else start moving fast and slow pointers simultaneously when the fast pointer reaches the end, the answer will the value of the slow pointer.
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
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;
}
int printKthfrommid( struct Node* head_ref, int k)
{
struct Node* slow = head_ref;
struct Node* fast = head_ref;
for ( int i = 0 ; i < k ; i++ )
{
if (fast && fast->next)
{
fast = fast->next->next;
}
else
{
return -1;
}
}
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
return slow->data;
}
int main()
{
struct Node* head = NULL;
int k = 2;
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;
}
|
Java
import java.io.*;
class Node {
int data;
Node next;
}
class GFG {
public Node head = null ;
public void push( int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head;
head = new_node;
}
public int printKthfrommid( int k)
{
Node slow = head;
Node fast = head;
for ( int i = 0 ; i < k; i++) {
if (fast != null && fast.next != null ) {
fast = fast.next
.next;
}
else {
return - 1 ;
}
}
while (fast != null && fast.next != null ) {
slow = slow.next;
fast = fast.next.next;
}
return slow.data;
}
public static void main(String[] args)
{
GFG ll = new GFG();
ll.push( 7 );
ll.push( 6 );
ll.push( 5 );
ll.push( 4 );
ll.push( 3 );
ll.push( 2 );
ll.push( 1 );
int k = 2 ;
System.out.print(ll.printKthfrommid(k));
}
}
|
Python
class Node:
def __init__( self , data):
self .data = data
self . next = None
class LinkedList:
def __init__( self ):
self .head = None
def push( self , new_data):
new_node = Node(new_data)
new_node. next = self .head
self .head = new_node
def printKthfrommid( self , k):
slow = self .head
fast = self .head
for i in range (k):
if (fast and fast. next ):
fast = fast. next . next
else :
return - 1
while (fast and fast. next ):
slow = slow. next
fast = fast. next . next
return slow.data
llist = LinkedList()
llist.push( 7 )
llist.push( 6 )
llist.push( 5 )
llist.push( 4 )
llist.push( 3 )
llist.push( 2 )
llist.push( 1 )
print (llist.printKthfrommid( 2 ))
|
C#
using System;
class Node {
public int data;
public Node next;
}
public class GFG {
Node head = null ;
void push( int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head;
head = new_node;
}
int printKthfrommid( int k)
{
Node slow = head;
Node fast = head;
for ( int i = 0; i < k; i++) {
if (fast != null && fast.next != null ) {
fast = fast.next
.next;
}
else {
return -1;
}
}
while (fast != null && fast.next != null ) {
slow = slow.next;
fast = fast.next.next;
}
return slow.data;
}
static public void Main()
{
GFG ll = new GFG();
ll.push(7);
ll.push(6);
ll.push(5);
ll.push(4);
ll.push(3);
ll.push(2);
ll.push(1);
int k = 2;
Console.Write(ll.printKthfrommid(k));
}
}
|
Javascript
class Node {
constructor(d) {
this .data = d;
this .next = null ;
}
}
function push(head_ref, new_data) {
let new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
}
function printKthfrommid(head_ref, k) {
let slow = head_ref.next;
let fast = head_ref.next;
for (let i = 0; i < k; i++) {
if (head_ref.next== null && head_ref.next== null ) {
head_ref.next = head_ref.next.next.next;
}
else {
return 2;
}
}
while (head_ref.next== null && head_ref.next.next== null ) {
slow = slow.next;
head_ref.next = head_ref.next.next.next;
}
return slow.data;
}
let head = new Node();
let k = 2;
push(head, 7);
push(head, 6);
push(head, 5);
push(head, 4);
push(head, 3);
push(head, 2);
push(head, 1);
console.log(printKthfrommid(head, 2));
|
Complexities Analysis:
- Time Complexity: O(n), where n is the length of the list.
- Auxiliary Space: O(1)
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
21 Dec, 2022
Like Article
Save Article