Read the Graph Info From the File and Store It as an Adjacency List in C

A graph is a data construction that consists of the following 2 components:
1. A finite fix of vertices also called as nodes.
2. A finite set of ordered pair of the form (u, v) called as edge. The pair is ordered considering (u, v) is not the aforementioned equally (v, u) in example of a directed graph(di-graph). The pair of the form (u, v) indicates that there is an border from vertex u to vertex v. The edges may contain weight/value/toll.
Graphs are used to represent many existent-life applications: Graphs are used to stand for networks. The networks may include paths in a metropolis or telephone network or circuit network. Graphs are also used in social networks similar linkedIn, Facebook. For example, in Facebook, each person is represented with a vertex(or node). Each node is a construction and contains data like person id, proper name, gender, and locale. See this for more applications of graph.
Following is an example of an undirected graph with 5 vertices.

The following two are the most commonly used representations of a graph.
1. Adjacency Matrix
two. Adjacency List
There are other representations also similar, Incidence Matrix and Incidence Listing. The pick of graph representation is situation-specific. It totally depends on the type of operations to be performed and ease of use.
Adjacency Matrix:
Adjacency Matrix is a 2D array of size Five x V where 5 is the number of vertices in a graph. Let the second array be adj[][], a slot adj[i][j] = one indicates that in that location is an edge from vertex i to vertex j. Adjacency matrix for undirected graph is e'er symmetric. Adjacency Matrix is also used to represent weighted graphs. If adj[i][j] = w, then there is an edge from vertex i to vertex j with weight w.

The adjacency matrix for the above case graph is:

Pros: Representation is easier to implement and follow. Removing an edge takes O(i) time. Queries like whether there is an edge from vertex 'u' to vertex 'v' are efficient and can be done O(1).
Cons: Consumes more space O(V^ii). Fifty-fifty if the graph is sparse(contains less number of edges), it consumes the same space. Adding a vertex is O(V^2) time.
Please see this for a sample Python implementation of adjacency matrix.
Adjacency List:
An array of lists is used. The size of the array is equal to the number of vertices. Permit the array be an array[]. An entry array[i] represents the listing of vertices adjacent to the i th vertex. This representation can also be used to stand for a weighted graph. The weights of edges tin can be represented as lists of pairs. Following is the adjacency list representation of the above graph.

Recommended: Delight solve it on " Do " first, before moving on to the solution.

Note that in the below implementation, we apply dynamic arrays (vector in C++/ArrayList in Java) to represent adjacency lists instead of the linked list. The vector implementation has advantages of cache friendliness.

C++

#include <bits/stdc++.h>

using namespace std;

void addEdge(vector< int > adj[], int u, int five)

{

adj[u].push_back(v);

adj[5].push_back(u);

}

void printGraph(vector< int > adj[], int 5)

{

for ( int v = 0; v < V; ++v) {

cout << "\n Adjacency list of vertex " << v

<< "\n caput " ;

for ( car x : adj[v])

cout << "-> " << x;

printf ( "\n" );

}

}

int main()

{

int V = five;

vector< int > adj[V];

addEdge(adj, 0, 1);

addEdge(adj, 0, 4);

addEdge(adj, 1, 2);

addEdge(adj, 1, iii);

addEdge(adj, 1, four);

addEdge(adj, 2, 3);

addEdge(adj, 3, four);

printGraph(adj, V);

return 0;

}

C

#include <stdio.h>

#include <stdlib.h>

struct AdjListNode {

int dest;

struct AdjListNode* next;

};

struct AdjList {

struct AdjListNode* head;

};

struct Graph {

int V;

struct AdjList* array;

};

struct AdjListNode* newAdjListNode( int dest)

{

struct AdjListNode* newNode

= ( struct AdjListNode*) malloc (

sizeof ( struct AdjListNode));

newNode->dest = dest;

newNode->next = Zilch;

return newNode;

}

struct Graph* createGraph( int 5)

{

struct Graph* graph

= ( struct Graph*) malloc ( sizeof ( struct Graph));

graph->V = V;

graph->array = ( struct AdjList*) malloc (

V * sizeof ( struct AdjList));

int i;

for (i = 0; i < V; ++i)

graph->array[i].head = NULL;

return graph;

}

void addEdge( struct Graph* graph, int src, int dest)

{

struct AdjListNode* cheque = NULL;

struct AdjListNode* newNode = newAdjListNode(dest);

if (graph->array[src].head == NULL) {

newNode->next = graph->array[src].head;

graph->array[src].head = newNode;

}

else {

cheque = graph->array[src].head;

while (bank check->next != Zero) {

check = check->next;

}

check->next = newNode;

}

newNode = newAdjListNode(src);

if (graph->array[dest].caput == NULL) {

newNode->next = graph->assortment[dest].head;

graph->array[dest].head = newNode;

}

else {

check = graph->array[dest].head;

while (check->side by side != Nothing) {

check = cheque->adjacent;

}

check->next = newNode;

}

}

void printGraph( struct Graph* graph)

{

int v;

for (v = 0; v < graph->V; ++v) {

struct AdjListNode* pCrawl = graph->array[v].head;

printf ( "\n Adjacency list of vertex %d\n caput " , five);

while (pCrawl) {

printf ( "-> %d" , pCrawl->dest);

pCrawl = pCrawl->next;

}

printf ( "\n" );

}

}

int master()

{

int 5 = five;

struct Graph* graph = createGraph(V);

addEdge(graph, 0, 1);

addEdge(graph, 0, 4);

addEdge(graph, 1, 2);

addEdge(graph, 1, 3);

addEdge(graph, 1, 4);

addEdge(graph, 2, iii);

addEdge(graph, 3, 4);

printGraph(graph);

return 0;

}

Java

import java.util.*;

class Graph {

static void addEdge(ArrayList<ArrayList<Integer> > adj,

int u, int v)

{

adj.get(u).add(5);

adj.get(5).add(u);

}

static void

printGraph(ArrayList<ArrayList<Integer> > adj)

{

for ( int i = 0 ; i < adj.size(); i++) {

System.out.println( "\nAdjacency list of vertex"

+ i);

System.out.print( "caput" );

for ( int j = 0 ; j < adj.get(i).size(); j++) {

Arrangement.out.print( " -> "

+ adj.go(i).get(j));

}

System.out.println();

}

}

public static void main(String[] args)

{

int V = 5 ;

ArrayList<ArrayList<Integer> > adj

= new ArrayList<ArrayList<Integer> >(Five);

for ( int i = 0 ; i < 5; i++)

adj.add( new ArrayList<Integer>());

addEdge(adj, 0 , 1 );

addEdge(adj, 0 , iv );

addEdge(adj, 1 , 2 );

addEdge(adj, 1 , three );

addEdge(adj, 1 , 4 );

addEdge(adj, 2 , iii );

addEdge(adj, 3 , four );

printGraph(adj);

}

}

Python3

grade AdjNode:

def __init__( self , information):

self .vertex = data

self . next = None

form Graph:

def __init__( self , vertices):

self .5 = vertices

self .graph = [ None ] * self .V

def add_edge( self , src, dest):

node = AdjNode(dest)

node. next = self .graph[src]

self .graph[src] = node

node = AdjNode(src)

node. next = self .graph[dest]

self .graph[dest] = node

def print_graph( self ):

for i in range ( self .5):

print ( "Adjacency list of vertex {}\n head" . format (i), end = "")

temp = self .graph[i]

while temp:

impress ( " -> {}" . format (temp.vertex), end = "")

temp = temp. next

print ( " \north" )

if __name__ = = "__main__" :

V = 5

graph = Graph(V)

graph.add_edge( 0 , 1 )

graph.add_edge( 0 , 4 )

graph.add_edge( ane , 2 )

graph.add_edge( i , 3 )

graph.add_edge( i , 4 )

graph.add_edge( 2 , 3 )

graph.add_edge( 3 , 4 )

graph.print_graph()

C#

using Arrangement;

using Arrangement.Collections.Generic;

class Graph {

static void addEdge(LinkedList< int >[] adj, int u, int v)

{

adj[u].AddLast(5);

adj[five].AddLast(u);

}

static void printGraph(LinkedList< int >[] adj)

{

for ( int i = 0; i < adj.Length; i++) {

Panel.WriteLine( "\nAdjacency listing of vertex "

+ i);

Panel.Write( "head" );

foreach ( var item in adj[i])

{

Console.Write( " -> " + particular);

}

Console.WriteLine();

}

}

public static void Main(Cord[] args)

{

int V = 5;

LinkedList< int >[] adj = new LinkedList< int >[ V ];

for ( int i = 0; i < V; i++)

adj[i] = new LinkedList< int >();

addEdge(adj, 0, 1);

addEdge(adj, 0, iv);

addEdge(adj, 1, 2);

addEdge(adj, ane, 3);

addEdge(adj, 1, 4);

addEdge(adj, 2, 3);

addEdge(adj, 3, 4);

printGraph(adj);

Console.ReadKey();

}

}

Javascript

<script>

function addEdge(adj,u,5)

{

adj[u].push(v);

adj[v].push(u);

}

function printGraph(adj)

{

for (let i = 0; i < adj.length; i++) {

certificate.write( "<br>Adjacency listing of vertex" + i+ "<br>" );

document.write( "head" );

for (allow j = 0; j < adj[i].length; j++) {

document.write( " -> " +adj[i][j]);

}

certificate.write( "<br>" );

}

}

permit Five = 5;

let adj= [];

for (let i = 0; i < Five; i++)

adj.push button([]);

addEdge(adj, 0, 1);

addEdge(adj, 0, 4);

addEdge(adj, 1, 2);

addEdge(adj, 1, 3);

addEdge(adj, ane, 4);

addEdge(adj, ii, 3);

addEdge(adj, 3, 4);

printGraph(adj);

</script>

Output:

          Adjacency list of vertex 0  caput -> 1-> four   Adjacency list of vertex 1  caput -> 0-> 2-> 3-> 4   Adjacency list of vertex 2  head -> ane-> 3   Adjacency list of vertex iii  head -> i-> 2-> 4   Adjacency list of vertex 4  head -> 0-> 1-> 3

Pros: Saves space O(|V|+|E|) . In the worst example, at that place can be C(Five, 2) number of edges in a graph thus consuming O(V^2) space. Adding a vertex is easier.
Cons: Queries like whether there is an border from vertex u to vertex v are not efficient and can be done O(V).

Reference:
http://en.wikipedia.org/wiki/Graph_%28abstract_data_type%29
Related Postal service:
Graph representation using STL for competitive programming | Prepare 1 (DFS of Unweighted and Undirected)
Graph implementation using STL for competitive programming | Set two (Weighted graph)
This article is compiled by Aashish Barnwal and reviewed past GeeksforGeeks team. Please write comments if you detect annihilation incorrect, or y'all want to share more than information nigh the topic discussed above.

jenningsamens1986.blogspot.com

Source: https://www.geeksforgeeks.org/graph-and-its-representations/

Share this post