Mastering Data Structures in Java: From Arrays to Graphs

Optimized Memory Use

Data structures impact memory usage. Different structures result in different application efficiency due to the differences in data allocation and deallocation. Proper structures that fit the specific goals reduce memory wastage and boost efficient memory use.

Supports Complex Functionality

Java data structure allows the efficient execution of complicated tasks that would have been impossible to achieve with basic data types. They allow developers to build relationships between data nodes and even build an entire intricate network.

Stronger Performance

Smart data structures allow the application to reduce processing time. This is especially important as the app’s data volume will inevitably increase. Shorter data time cycle means faster performance, fewer bottlenecks, and enhanced user experience.

Data Structure Reusability

Once a data structure is put in place, it can be reused across the program, even in other projects, as long as it fits the specific purpose. This not only saves time but also increases the modularity of an app.

Enhanced Data Management

Gathering data in one place makes it easier and faster to organize, access, and complete tasks. The right data structures make every task – whether you are searching or modifying data – much faster. It also makes spotting errors easier, increases readability, and leads to an overall productivity boost.

Better Problem-Solving

Every data structure in Java, from the most basic to the complex ones, aims to solve common problems in Java. These structures help developers understand the nature of the problem and program, and have high-level and ready-to-use tools to solve potential problems efficiently.

It’s time we dig in deep and learn what each Java data structure entails.

Pros and Cons of Arrays

The main advantages of arrays are as follows:

• With the help of indexes, developers can access elements randomly.
• It allows easy storing, sorting, and manipulation of data.

However, the limits of arrays can be:

• Arrays can only store similar types of data.
• The size of the data is fixed, meaning it can’t be increased or decreased once declared.
• The memory needs to be contiguous (next to one another) to be allocated.

Types of Arrays

Depending on the specific aim of a task, you can utilize different types of arrays.

One-dimensional Array

A one-dimensional array holds a list of elements in a single row. It is also known as a linear array. The data will be stored in boxes like this:

Here is an array example of city names

String[] cities = {"Hanoi", "Tokyo", "Paris", "New York"};

Two-dimensional Array

Two-dimensional arrays are stored in rows and columns. Imagine it’s something like this:

Below is a specific example of a table with two rows and three columns:

int[][] numbers = {
    {1, 2, 3},
    {4, 5, 6}
};
System.out.println(numbers[0][0]); // Prints 1 (first row, first column)
System.out.println(numbers[1][2]); // Prints 6 (second row, third column)

Multi-dimensional Array

A combination of two or more arrays, or in other words, it is an array of arrays. Here is a quick example:

public class MultiDimensionalArrayExample {
    public static void main(String[] args) {
        int[][][] numbers = {
            { {1, 2, 3}, {4, 5, 6} },
            { {7, 8, 9}, {10, 11, 12} }
        };
        System.out.println(numbers[0][0][1]); // Prints 2
        System.out.println(numbers[1][1][2]); // Prints 12
    }
}

The output would look something like this:

2
12

How to Create a Linked List

In Java, creating a linked list requires you to master the following tasks:

• Creating a node
• Linking the nodes
• Append the nodes
• Insert the nodes
• Deleting a node

Let’s take a closer look at how to achieve these tasks with simple examples.

Creating a Node

A node holds two things — data (like a number or word) and a link to the next node.

class Node {
    int data;
    Node next;
    Node(int data) { this.data = data; }
}

Connect Nodes:

You link one node to the next using the next pointer.

Node first = new Node(10);
Node second = new Node(20);
first.next = second; // Connect first to second

Append Nodes (add at the end):

Go to the last node and link a new one after it.

Node third = new Node(30);
second.next = third; // Add to the end

Insert Nodes (add in the middle):

Create a new node and adjust the links so it fits between two existing nodes.

Node newNode = new Node(15);
newNode.next = second;
first.next = newNode; // Insert between first and second

Delete nodes:

Skip over the node you want to remove by changing the link.

first.next = second.next; // Removes 'second' node

Key Features and Operations of a Stack

The most crucial feature of a stack is that it follows the LIFO, or last-in, first-out principle. What this means is that the latest element inserted is also the first one to be removed. Developers can only access a stack from the top, and the insertion or removal of an element is also done from the very top.

This leads us to the stack’s core operations:

• Push: inserting an element at the top
• Pop: removing an element
• IsEmpty: checking if the stack is empty
• IsFull: checking if the stack is full
• Peek: getting to the top element of the stack but not removing it

Stacks are simple and efficient, managing data using the LIFO principle. However, it is not suitable for random access and has the potential to overflow, causing data loss.

Implementing Stack in Java Programming

One common approach to implementing a stack is using a linked list (using arrays is also another common stack implementation method).

public class LinkedStack {
    private Node top;  // the top (head) node of the stack
    private class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    public LinkedStack() {
        top = null;  // initially, stack is empty
    }

    public boolean isEmpty() {
        return top == null;
    }

    public void push(int x) {
        Node newNode = new Node(x);
        newNode.next = top;  // link new node to current top
        top = newNode;       // new node becomes the new top
    }

    public int pop() {
        if (isEmpty()) {
            System.out.println("Stack is empty");
            return -1;  // or throw exception
        }
        int value = top.data;
        top = top.next;  // remove top node
        return value;
    }

    public int peek() {
        if (isEmpty()) {
            System.out.println("Stack is empty");
            return -1;
        }
        return top.data;
    }

    public void display() {
        Node curr = top;
        System.out.print("Stack: ");
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedStack stack = new LinkedStack();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.display();              // prints: Stack: 30 20 10
        System.out.println(stack.pop());   // prints: 30
        stack.display();              // prints: Stack: 20 10
        System.out.println(stack.peek());  // prints: 20
    }
}

Queue Key Features and Operations

A queue is made up of two main parts: the front and the back. Insertion can take place from the front, and deletion takes place from the back. Here is a visual example for easy visualization:

The structure of your queue doesn’t have to be fixed – you can have the front on the right and the back on the left.

To remove and insert items to your queue, here are the key operations that you need to know:

• Enqueue: adding an element to the back end of the queue
• Dequeue: removing an element
• Front/Peek: to get the first element of the queue without removing it.
• IsEmpty: checking if the queue is empty
• IsFull: checking if the queue is full.

Queue Implementation in Java

Similar to a stack, there are several approaches to queue implementation (e.g., using an array or a priority queue). Here is a simple example using linked lists that automatically resizes and applies the FIFO principle seamlessly.

import java.util.*;

public class QueueExample {
    public static void main(String[] args) {
        Queue< Integer > q = new LinkedList<>();
        q.add(10);
        q.add(20);
        q.add(30);
        System.out.println(q);        // Output: [10, 20, 30]
        q.remove();                   // Removes 10
        System.out.println(q.peek()); // Shows 20 (front element)
        System.out.println(q);        // Output: [20, 30]
    }
}

Priority Queue

A special type of queue data structure is a priority queue. Instead of following the FIFO rule, a priority queue removes an element based on a priority level. You can think about boarding priorities in flights: business class passengers are prioritized and board first, then come the other passengers in economy class.

There are several ways to implement a priority queue. You can use a linked list, an array, a binary search tree, or a heap data structure. A heap data structure is considered to be the most effective implementation.

Binary Tree Types

There are seven common types of binary trees.

• Full Binary Tree. Every node has 0 or 2 children.
• Complete Binary Tree. All levels are filled except possibly the last, which is filled from left to right.
• Perfect Binary Tree. Both are complete; all leaves are on the same level.
• Balanced Binary Tree. The height difference between the left and right subtrees is at most 1.
• Binary Search Tree (BST). Left child < parent < right child; used for fast searching and sorting.
• Degenerate (Skewed) Binary Tree. Each node has only one child; it behaves like a linked list.
• Threaded Binary Tree. Uses links instead of null pointers to enable faster in-order traversal.

Code Example of Binary Tree Data Structure

Here is an example of a binary tree with five nodes that will print the nodes in order.

class Node {
    int value;
    Node left, right;

    // Constructor to create a new node
    Node(int item) {
        value = item;
        left = right = null;
    }
}

class BinaryTree {
    // Root node of the tree
    Node root;

    // Constructor
    BinaryTree() {
        root = null;
    }

    // Display tree in-order (Left → Root → Right)
    void inOrder(Node node) {
        if (node == null)
        return;
        inOrder(node.left);
        System.out.print(node.value + " ");
        inOrder(node.right);
    }

    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        // Create tree nodes
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        System.out.println("In-order traversal of the binary tree:");
        tree.inOrder(tree.root);
    }
}

Implementation of Heap Data Structure

Below is an example of a max heap data structure using his uses Java’s built-in PriorityQueue with Collections.reverseOrder().

import java.util.PriorityQueue;
import java.util.Collections;

public class MaxHeapExample {
        public static void main(String[] args) {
        // Create a max heap using PriorityQueue
        PriorityQueue< Integer > maxHeap =
            new PriorityQueue<>(Collections.reverseOrder());

        // Add elements
        maxHeap.add(10);
        maxHeap.add(20);
        maxHeap.add(15);
        maxHeap.add(30);
        maxHeap.add(40);
        maxHeap.add(5);
        System.out.println("Max Heap: " + maxHeap);

        // Remove the largest element
        System.out.println("Extracted Max: " + maxHeap.poll());
        System.out.println("After extraction: " + maxHeap);
    }
}

Example of HashMap Code

Below is an example of a HashMap of fruit names and their quantities that allows the addition, removal, and retrieval of items.

import java.util.HashMap;
public class SimpleHashMapExample {
    public static void main(String[] args) {

        // Create a HashMap
        HashMap< String, Integer > map = new HashMap<>();

        // Add key-value pairs
        map.put("Apple", 3);
        map.put("Banana", 5);
        map.put("Orange", 2);

        // Access a value using its key
        System.out.println("Bananas: " + map.get("Banana"));

        // Remove a key-value pair
        map.remove("Orange");

        // Print all key-value pairs
        System.out.println("Current map: " + map);
    }
}

Types of Graphs

There are seven main types of graphs every developer needs to know.

• Undirected Graphs: In this type of graph, edges have no direction. Connections go both ways. Think of mutual friendships on social media.
• Directed Graphs (Digraphs): Edges have direction, showing one-way relationships, like links between web pages.
• Weighted Graphs: Each edge has a numeric value (weight) that represents cost, distance, or importance. This is useful in transport or network optimization.
• Unweighted Graphs: Edges only show connections, without any weights, and are often used in basic social or communication networks.
• Cyclic and Acyclic Graphs: Cyclic graphs have loops; acyclic ones don’t. Directed acyclic graphs (DAGs) are often used in project scheduling to avoid circular dependencies.
• Connected and Disconnected Graphs: Connected graphs have a path between every node; disconnected ones have isolated parts.
• Bipartite Graphs: Nodes are divided into two groups, and edges only connect nodes from different groups, which is useful for matching or resource allocation problems.

Graph Representation in Java

In Java, the two most common ways to represent graphs are adjacency matrices and adjacency lists.

Adjacency Matrix

Represents connections using a 2D array where each cell shows whether two nodes are connected.

An adjacency matrix is best for dense graphs (with lots of connections).

int[] [] graph = {
    {0, 1, 1},
    {1, 0, 0},
    {1, 0, 0}
} ;

// Node 1 connects to nodes 2 and 3

Adjacency List

Each node keeps a list of its neighbors. This is more memory-efficient for sparse graphs (with fewer connections).

import java.util.*;
List< List< Integer >> graph = new ArrayList<>();
graph.add(List.of(2, 3)); // Node 1 → 2, 3
graph.add(new ArrayList<>()); // Node 2 → none
graph.add(new ArrayList<>()); // Node 3 → none