Given a singly linked list and the task is to find the middle of the linked list.
Examples:
Input : 1->2->3->4->5
Output : 3
Input : 1->2->3->4->5->6
Output : 4
We have already discussed Iterative Solution. In this post iterative solution is discussed. Count total number of nodes in the list in recursive manner and do half of this, suppose this value is n. Then rolling back through recursion decrement n by one for each call. Return the node where n is zero.
Implementation:
C++
#include <iostream>
using namespace std;
struct Node
{
int data;
struct Node* next;
};
Node* newLNode( int data)
{
Node* temp = new Node;
temp->data = data;
temp->next = NULL;
return temp;
}
void midpoint_util(Node* head, int * n, Node** mid)
{
if (head == NULL)
{
*n = (*n) / 2;
return ;
}
*n = *n + 1;
midpoint_util(head->next, n, mid);
*n = *n - 1;
if (*n == 0)
{
*mid = head;
}
}
Node* midpoint(Node* head)
{
Node* mid = NULL;
int n = 1;
midpoint_util(head, &n, &mid);
return mid;
}
int main()
{
Node* head = newLNode(1);
head->next = newLNode(2);
head->next->next = newLNode(3);
head->next->next->next = newLNode(4);
head->next->next->next->next = newLNode(5);
Node* result = midpoint(head);
cout << result->data << endl;
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node next;
};
static Node newLNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
static int n;
static Node mid;
static void midpoint_util(Node head )
{
if (head == null )
{
n = (n) / 2 ;
return ;
}
n = n + 1 ;
midpoint_util(head.next);
n = n - 1 ;
if (n == 0 )
{
mid = head;
}
}
static Node midpoint(Node head)
{
mid = null ;
n = 1 ;
midpoint_util(head);
return mid;
}
public static void main(String args[])
{
Node head = newLNode( 1 );
head.next = newLNode( 2 );
head.next.next = newLNode( 3 );
head.next.next.next = newLNode( 4 );
head.next.next.next.next = newLNode( 5 );
Node result = midpoint(head);
System.out.print( result.data );
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
def newLNode(data):
temp = Node(data)
temp.data = data
temp. next = None
return temp
mid = None
n = 0
def midpoint_util(head ):
global n
global mid
if (head = = None ):
n = int ((n) / 2 )
return
n = n + 1
midpoint_util(head. next )
n = n - 1
if (n = = 0 ):
mid = head
def midpoint(head):
global n
global mid
mid = None
n = 1
midpoint_util(head)
return mid
if __name__ = = '__main__' :
head = newLNode( 1 )
head. next = newLNode( 2 )
head. next . next = newLNode( 3 )
head. next . next . next = newLNode( 4 )
head. next . next . next . next = newLNode( 5 )
result = midpoint(head)
print ( result.data )
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static Node newLNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
static int n;
static Node mid;
static void midpoint_util(Node head )
{
if (head == null )
{
n = (n) / 2;
return ;
}
n = n + 1;
midpoint_util(head.next);
n = n - 1;
if (n == 0)
{
mid = head;
}
}
static Node midpoint(Node head)
{
mid = null ;
n = 1;
midpoint_util(head);
return mid;
}
public static void Main()
{
Node head = newLNode(1);
head.next = newLNode(2);
head.next.next = newLNode(3);
head.next.next.next = newLNode(4);
head.next.next.next.next = newLNode(5);
Node result = midpoint(head);
Console.WriteLine( result.data );
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .next = null ;
}
};
function newLNode(data)
{
var temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
var n = 0;
var mid = null ;;
function midpoint_util(head)
{
if (head == null )
{
n = (n) / 2;
return ;
}
n = n + 1;
midpoint_util(head.next);
n = n - 1;
if (n == 0)
{
mid = head;
}
}
function midpoint(head)
{
mid = null ;
n = 1;
midpoint_util(head);
return mid;
}
var head = newLNode(1);
head.next = newLNode(2);
head.next.next = newLNode(3);
head.next.next.next = newLNode(4);
head.next.next.next.next = newLNode(5);
var result = midpoint(head);
document.write( result.data );
</script>
|
Time Complexity: O(N) where N is the number of nodes in the Linked List.
Auxiliary Space: O(N), due to recursion call stack