LinkedList

A LinkedList in Java is a linear data structure that consists of a sequence of elements, where each element is a separate object called a node. Each node contains two parts: the data it holds and a reference (or pointer) to the next node in the sequence. Unlike arrays, where elements are stored in contiguous memory locations, Linked List elements are not necessarily stored in contiguous memory locations, and each element points to the next element in the sequence.

Here’s a breakdown of key points regarding Linked List

1. Node-Based Structure: Linked-List is implemented as a series of nodes, where each node contains a data element and a reference to the next node in the sequence. This structure allows for efficient insertion and deletion of elements at both ends (head and tail) of the list.

2. Dynamic Size: Linked List can grow or shrink dynamically as elements are added or removed. Unlike arrays, Linked-List does not have a fixed size, and it can adjust its size as needed.

3. Bidirectional Traversal: In addition to forward traversal, where you can start at the head and move towards the tail, Linked-List supports bidirectional traversal. Each node contains a reference to the next node as well as a reference to the previous node, allowing for efficient traversal in both directions.

4. Efficient Insertion and Deletion: Linked-List provides constant-time performance for insertion and deletion of elements at both ends (head and tail) of the list. However, accessing elements by index in a Linked List requires traversing the list from the beginning or end, which can be slower compared to ArrayList.

Now, let's provide a Java code example to illustrate the usage of Linked-List:


import java.util.Linked List;

public class Linked-ListExample {
    public static void main(String[] args) {
        // Creating a Linked-List
        LinkedList<String> linkedList = new Linked-List<>();

        // Adding elements to the Linked-List
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Orange");

        // Accessing elements
        System.out.println("First element: " + linked-List.getFirst());
        System.out.println("Last element: " + linked-List.getLast());

        // Adding elements at specific positions
        linked-List.addFirst("Grapes");
        linked-List.addLast("Pineapple");

        // Removing elements
        linked-List.removeFirst();
        linked-List.removeLast();

        // Iterating through the LinkedList
        System.out.println("LinkedList elements:");
        for (String fruit : linkedList) {
            System.out.println(fruit);
        }
    }
}

In this example, we create a Linked List named linked-List to store strings. We add elements to the using the add() method, and we can access the first and last elements of the list using the getFirst() and getLast() methods, respectively. Additionally, we demonstrate adding elements at the beginning and end of the list using addFirst() and addLast(), and removing elements from the beginning and end of the list using removeFirst() and removeLast(). Finally, we iterate through the using a for-each loop to print its elements.

Homepage

Readmore