Java Program to Represent Graphs Using Linked List - GeeksforGeeks

26 Jul, 2021
Data structures are divided into two categories Linear data structures and Non-Linear data structures. The major disadvantage of the linear data structure is we cannot arrange the data of linear data structure in hierarchy manner that’s why in the computer field we use Non-Linear data structures. The most commonly used Non-Linear data structure is Graphs and Trees both data structures can be implemented using Linear data structures. In this article, we will discuss how to represent Graphs using Linked List.
Graphs consist of a finite set of vertices(or nodes) and a set of edges that connect a pair of nodes. Graphs are represented in two different ways. One method is using adjacency List representation and the second is adjacency matrix representation. Adjacency List representation is mostly used because of dynamic memory allocation using list representation.
Graphs are of two types:
Directed Graphs: In this arrangement of graphs, every node is directed to one vertex is called directed Graphs.
Undirected Graphs: In this arrangement of graphs, two nodes are connected using bi-direction vertex is called undirected graphs.
Undirected Graphs representation: Maximum number of a vertex in the undirected graphs is n*(n-1) where n is the total number of nodes present in the Undirected Graphs.
LinkedList Representation of undirected Graphs is as follows:
 In undirected graphs, two nodes are connected in bi-direction vertex. We can use both Array List and Linked List collections to represent the undirected graphs. In Linked List the Manipulation of the data is faster than the Array List because Array List internally used the dynamic array to store the data whereas Linked List used Doubly Linked List that is faster in the operation of manipulation but not in accessing the elements.
Implementation: Here we will be discussing out both types of graphs in order to implement the same. 
Example 1
Java
// Java Program to Implement the Unidirectional Graph// Using Linked List // Importing required classes from packagesimport java.io.*;import java.util.*; // Main classclass GFG {     // Method 1    // To make pair of nodes    static void    addEdge(LinkedList<LinkedList<Integer> > Adj, int u,            int v)    {        // Creating bi-directional vertex        Adj.get(u).add(v);        Adj.get(v).add(u);    }     // Method 2    // To print the adjacency list    static void    printadjacencylist(LinkedList<LinkedList<Integer> > adj)    {        for (int i = 0; i < adj.size(); ++i) {             // Printing the head            System.out.print(i + "->");             for (int v : adj.get(i)) {                // Printing the nodes                System.out.print(v + " ");            }             // Now a new lin eis needed            System.out.println();        }    }     // Method 3    // Main driver method    public static void main(String[] args)    {         // Creating vertex        int V = 5;         LinkedList<LinkedList<Integer> > adj            = new LinkedList<LinkedList<Integer> >();        for (int i = 0; i < V; ++i) {            adj.add(new LinkedList<Integer>());        }         // Inserting nodes        // Custom input node elements        addEdge(adj, 0, 1);        addEdge(adj, 0, 4);        addEdge(adj, 1, 2);        addEdge(adj, 1, 3);        addEdge(adj, 1, 4);        addEdge(adj, 2, 3);        addEdge(adj, 3, 4);         // Printing adjacency list        printadjacencylist(adj);    }}
  
0->1 4 
1->0 2 3 4 
2->1 3 
3->1 2 4 
4->0 1 3 
 
Now jumping onto the next type of graphs that is our directed graphs representation using Linked List. In directed graphs, two nodes are connected in uni-direction vertex.
 
 
Example 2
 
Java
// Java Program to Implement the Directed Graph// Using Linked List // Importing standard classes from respectively packagesimport java.io.*;import java.util.*; // Main classclass GFG {     // Method 1    // To make pair of nodes    static void    addEdge(LinkedList<LinkedList<Integer> > Adj, int u,            int v)    {        // Creating unidirectional vertex        Adj.get(u).add(v);    }     // Method 2    // To print the adjacency List    static void    printadjacencylist(LinkedList<LinkedList<Integer> > adj)    {        for (int i = 0; i < adj.size(); ++i) {             // Printing the head            if (adj.get(i).size() != 0) {                System.out.print(i + "->");                for (int v : adj.get(i)) {                     // Printing the nodes                    System.out.print(v + " ");                }                 // A new line is needed                System.out.println();            }        }    }     // Method 3    // Main driver method    public static void main(String[] args)    {        // Creating vertex        int V = 5;         LinkedList<LinkedList<Integer> > adj            = new LinkedList<LinkedList<Integer> >();         for (int i = 0; i < V; ++i) {            adj.add(new LinkedList<Integer>());        }        // Inserting nodes        // Custom input elements        addEdge(adj, 0, 1);        addEdge(adj, 0, 4);        addEdge(adj, 1, 2);         // Printing adjacency List        printadjacencylist(adj);    }}
  
0->1 4 
1->2 
 
simmytarika5
Picked
Graph
Java
Java Programs
Linked List
Linked List
Java
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Best First Search (Informed Search)
Graph Coloring | Set 2 (Greedy Algorithm)
Maximum Bipartite Matching
Longest Path in a Directed Acyclic Graph
Graph Coloring | Set 1 (Introduction and Applications)
Arrays in Java
Split() String method in Java with examples
For-each loop in Java
Object Oriented Programming (OOPs) Concept in Java
HashMap in Java with Examples