Skip to content
Related Articles

Related Articles

Improve Article

Java Program to Get the First and the Last Element of a Linked List

  • Last Updated : 11 Jun, 2021

A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The given task is to retrieve the first and the last element of a given linked list.

Properties of a Linked List:

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

  • Elements are stored in a non-contiguous manner.
  • Every element is an object which contains a pointer to the next element.
Input: [2, 5, 5, 7, 10, 6]

Output: First element is : 2
        Last element is : 6

Input: [1]

Output: First element is : 1
        Last element is : 1

Approach 1: Using in-built libraries

Use the pre-built LinkedList class in the java.util package to build a Linked List and use the pre-defined methods to fetch the respective values.



Example: Below is the implementation of the above approach:

Java




// Java Program to get the first and the last element of a
// Linked List
 
// Importing the Linked List class from the util package
import java.util.LinkedList;
 
class AccessFirstAndLastElements {
    public static void main(String[] args)
    {
        // Initializing the Linked List
        LinkedList<Integer> ll = new LinkedList<>();
 
        // Adding elements to the Linked List
        ll.add(2);
        ll.add(5);
        ll.add(5);
        ll.add(7);
        ll.add(10);
        ll.add(6);
 
        // Getting the first element
        System.out.println("First Element is : "
                           + ll.getFirst());
 
        // Getting the last element
        System.out.println("Last Element is : "
                           + ll.getLast());
    }
}
Output
First Element is : 2
Last Element is : 6

Time Complexity:  getFirst() takes O(1) time and getLast() takes O(n) where n is the number of elements in the Linked List.

Approach 2: Without using in-built methods 

  • Create a generic Node class.
  • Create our very own Linked List class using the Node class.
  • Create the required add(), getFirst() and getLast() methods.
  • Initialize the Linked List.
  • Use the respective get methods to fetch the values.

Example: Below is the implementation of the above approach: 

Java




// Java program to get the first and last element from a
// Linked List
 
// A Generic Node class is used to create a Linked List
class Node<E> {
 
    // Data Stored in each Node of the Linked List
    E data;
 
    // Pointer to the next node in the Linked List
    Node<E> next;
 
    // Node class constructor used to initializes the data
    // in each Node
    Node(E data) { this.data = data; }
}
 
class LinkedList<E> {
 
    // Points to the head of the Linked List
    // i.e the first element
    Node<E> head;
    int size = 0;
 
    // Addition of elements to the tail of the Linked List
    public void add(E element)
    {
 
        // Checks whether the head is created else creates a
        // new one
        if (head == null) {
            head = new Node<>(element);
            size++;
            return;
        }
 
        // The Node which needs to be added at
        // the tail of the Linked List
        Node<E> add = new Node<>(element);
 
        // Storing the instance of the
        // head pointer
        Node<E> temp = head;
 
        // The while loop takes us to the tail of the Linked
        // List
        while (temp.next != null) {
 
            temp = temp.next;
        }
 
        // New Node is added at the tail of
        // the Linked List
        temp.next = add;
 
        // Size of the Linked List is incremented as
        // the elements are added
        size++;
    }
 
    // Retrieves the first element of the Linked List
    public E getFirst() throws Exception
    {
 
        // Throws an Exception if the List is empty
        if (head == null) {
            throw new Exception(
                "No elements found in Linked List");
        }
 
        // Returns the first element
        return head.data;
    }
 
    // Retrieves the last element of the Linked List
    public E getLast() throws Exception
    {
        // Throws an Exception if the List is empty
        if (head == null) {
            throw new Exception(
                "No elements found in Linked List");
        }
 
        Node<E> temp = head;
 
        // The while loop takes us to the tail of the Linked
        // List
        while (temp.next != null) {
            temp = temp.next;
        }
 
        // Returns the last element
        return temp.data;
    }
}
 
class AccessFirstAndLastElements {
    public static void main(String[] args) throws Exception
    {
        // Initializing the Linked List
        LinkedList<Integer> ll = new LinkedList<>();
 
        // Adding elements to the Linked List
        ll.add(2);
        ll.add(5);
        ll.add(5);
        ll.add(7);
        ll.add(10);
        ll.add(6);
 
        // Getting the first element
        System.out.println("First Element is : "
                           + ll.getFirst());
 
        // Getting the last element
        System.out.println("Last Element is : "
                           + ll.getLast());
    }
}
Output
First Element is : 2
Last Element is : 6

Time Complexity: getFirst() takes O(1) time and getLast() takes O(n) where n is the number of elements in the Linked List.

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :