Middle Node of a Linked List in Java

In this section, we will learn about finding the middle node of a linked list in Java. We will also explore the various ways to find the middle node.

Given: The first node or the Head of the Linked List is given (it is 14 in our case)

14 -> 16 -> 17 -> 11 -> 15 -> 18 -> 13 -> 12 -> NULL

Return:

Given:

13 -> 17 -> 90 -> 76 -> 45 -> 32 -> 10 -> NULL

Return:

Approach 1: Using two pointers

In this approach, we will use two pointers, one is fast (moves two steps at a time), and another is slow (moves one step at a time). It is obvious that the fast pointer reaches the end of the list before the two-pointers. When the fast pointer reaches the end of the linked list, then we check the position of the slow pointer that is moving one step at a time. The node at which the slow pointer is pointing in the middle node of the linked list.

FileName: TwoPointerExample1.java

class Node
{
int num;
Node next;
// constructor of the class Node
Node(int n)
{
this.num = n;
this.next = null;
}
}
public class TwoPointerExample1
{
public void findNode(Node n)
{
if(n == null) 
{
return;
}
Node slow = n;
Node fast = n;
while(fast != null && fast.next != null)
{
// fast pointer is taking two steps at a time
fast = fast.next.next;
// slow pointer is taking one step at a time
slow = slow.next;
}
System.out.println("The middle node of the linked list is: " + slow.num);
}
// main method
public static void main(String argvs[])
{
// head node of the linked list
Node h = new Node(13);
// remaining node of the linked list
h.next = new Node(17);
h.next.next = new Node(90);
h.next.next.next = new Node(76);
h.next.next.next.next = new Node(45);
h.next.next.next.next.next = new Node(32);
h.next.next.next.next.next.next = new Node(10);
// creating an object of the class TwoPointerExample1
TwoPointerExample1 obj = new TwoPointerExample1();
// invoking the method findNode()
obj.findNode(h);
}
}

Output:

The middle node of the linked list is: 15

Approach 2: Using Stack

In this approach, we will use a stack to find the middle node of the linked list. First, we will find the total size of the linked list. Now, we will push all of the nodes of the linked list in the stack. Then, we divide the total size by 2, and then whatever number comes, we do the pop operation on stack till that number of times. The top or peek node present in the stack is our answer; the middle node.

FileName: StackExample1.java

// important import statement
import java.util.*;
class Node
{
int num;
Node next;
// constructor of the class Node
Node(int n)
{
this.num = n;
this.next = null;
}
}
public class StackExample1
{
// a method to find the size 
// of the linked list
public int size(Node h)
{
int sz = 0;
while(h != null)
{
sz = sz + 1;
h = h.next;
}
return sz;
}
public void findNode(Node n)
{
Stack<Node> stk = new Stack<Node>();
Node h = n;
// pushing the node from the stack
while(h != null)
{
stk.push(h);
h = h.next;
}
// invoking the method size() to 
// find the size of the linked list
int s = size(n);
// dividing the size by 2
s = s / 2;
while(s != 0)
{
// pop the elements from the node
stk.pop();
s = s - 1;
}
// the value of the top node present in the stack 
int val = (stk.peek()).num;
System.out.println("The middle node of the linked list is: " + val);
}
// main method
public static void main(String argvs[])
{
// head node of the linked list
Node h = new Node(13);
// remaining node of the linked list
h.next = new Node(17);
h.next.next = new Node(90);
h.next.next.next = new Node(76);
h.next.next.next.next = new Node(45);
h.next.next.next.next.next = new Node(32);
h.next.next.next.next.next.next = new Node(10);
// creating an object of the class StackExample1
StackExample1 obj = new StackExample1();
// invoking the method findNode()
obj.findNode(h);
}
}

Output:

The middle node of the linked list is: 76

Approach 3: Using Queue

In this approach, we will use a queue to find the middle node of the linked list. First, we will find the total size of the linked list. Now, we will push all of the nodes of the linked list in the queue. Then, we divide the total size by 2, and then whatever number comes, we do the removal of nodes from the queue till that number of times. The top or peek node present in the queue is our answer; the middle node.

FileName: QueueExample1.java

// important import statement
import java.util.*;
class Node
{
int num;
Node next;
// constructor of the class Node
Node(int n)
{
this.num = n;
this.next = null;
}
}
public class QueueExample1
{
// a method to find the size 
// of the linked list
public int size(Node h)
{
int sz = 0;
while(h != null)
{
sz = sz + 1;
h = h.next;
}
return sz;
}
public void findNode(Node n)
{
Queue<Node> que = new LinkedList<Node>();
Node h = n;
// pushing the node from the stack
while(h != null)
{
que.add(h);
h = h.next;
}
// invoking the method size() to 
// find the size of the linked list
int s = size(n);
// dividing the size by 2
s = s / 2;
while(s != 0)
{
// pop the elements from the node
que.remove();
s = s - 1;
}
// the value of the top node present in the stack 
int val = (que.peek()).num;
System.out.println("The middle node of the linked list is: " + val);
}
// main method
public static void main(String argvs[])
{
// head node of the linked list
Node h = new Node(13);
// remaining node of the linked list
h.next = new Node(17);
h.next.next = new Node(90);
h.next.next.next = new Node(76);
h.next.next.next.next = new Node(45);
h.next.next.next.next.next = new Node(32);
h.next.next.next.next.next.next = new Node(10);
// creating an object of the class QueueExample1
QueueExample1 obj = new QueueExample1();
// invoking the method findNode()
obj.findNode(h);
}
}

Output:

The middle node of the linked list is: 76

Approach 4: Using one pointer

In this approach, we will use only one pointer to find the middle node of the linked list. First, we will find the total size of the linked list. Then, we divide the total size by 2, and then whatever number comes, we move the pointer, starting from the head node, to that number of times. The node at which the pointer is pointing is the middle node of the linked list.

FileName: OnePointerExample1.java

class Node
{
int num;
Node next;

// constructor of the class Node
Node(int n)
{
this.num = n;
this.next = null;
}
}
public class OnePointerExample1
{

// a method to find the size 
// of the linked list
public int size(Node h)
{
int sz = 0;
while(h != null)
{
sz = sz + 1;
h = h.next;
}

return sz;
}

public void findNode(Node n)
{

Node h = n;


// invoking the method size() to 
// find the size of the linked list
int s = size(n);

// dividing the size by 2
s = s / 2;

while(s != 0)
{
// moving h to the next node
h = h.next;

s = s - 1;
}

// the value of the node pointed by the node h 
int val = h.num;
System.out.println("The middle node of the linked list is: " + val);


}

// main method
public static void main(String argvs[])
{
// head node of the linked list
Node h = new Node(13);

// remaining node of the linked list
h.next = new Node(17);
h.next.next = new Node(90);
h.next.next.next = new Node(76);
h.next.next.next.next = new Node(45);
h.next.next.next.next.next = new Node(32);
h.next.next.next.next.next.next = new Node(10);

// creating an object of the class OnePointerExample1
OnePointerExample1 obj = new OnePointerExample1();

// invoking the method findNode()
obj.findNode(h);
}
}

Output:

The middle node of the linked list is: 76

Approach 5: Using Counter

In this approach also, we will use two pointers to find the middle node of the linked list with the help of a counter. We will keep incrementing the counter by 1 each time we move to the next node. When the value of the counter is odd, we will move the other pointer (say odd pointer) starting from the beginning (head node). After the end of the iteration, the position at which the odd pointer is pointing; is the middle node.'

FileName: CounterExample.java

class Node
{
int num;
Node next;

// constructor of the class Node
Node(int n)
{
this.num = n;
this.next = null;
}
}
public class CounterExample
{

// a method to find the size 
// of the linked list
public int size(Node h)
{
int sz = 0;
while(h != null)
{
sz = sz + 1;
h = h.next;
}

return sz;
}

public void findNode(Node n)
{

Node h = n;
Node s = n;

int sz = 0;
while(h != null)
{

// when the value of the sz is odd
// we move the pointer s by 1
if(sz % 2 == 1)
{
s = s.next;
}

sz = sz + 1;

h = h.next;
}

// the value of the node pointed by the node s
int val = s.num;
System.out.println("The middle node of the linked list is: " + val);


}

// main method
public static void main(String argvs[])
{
// head node of the linked list
Node h = new Node(13);

// remaining node of the linked list
h.next = new Node(17);
h.next.next = new Node(90);
h.next.next.next = new Node(76);
h.next.next.next.next = new Node(45);
h.next.next.next.next.next = new Node(32);
h.next.next.next.next.next.next = new Node(10);

// creating an object of the class CounterExample
CounterExample obj = new CounterExample();

// invoking the method findNode()
obj.findNode(h);
}
}

Output:

The middle node of the linked list is: 76

Next TopicPernicious Number in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Middle Node of a Linked List in Java

Approach 1: Using two pointers

Approach 2: Using Stack

Approach 3: Using Queue

Approach 4: Using one pointer

Approach 5: Using Counter

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA