Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Count number of edges in an undirected graph

Given an adjacency list representation undirected graph. Write a function to count the number of edges in the undirected graph. Expected time complexity : O(V) Examples:

Input : Adjacency list representation of
        below graph.  
Output : 9

Idea is based on Handshaking Lemma. Handshaking lemma is about undirected graph. In every finite undirected graph number of vertices with odd degree is always even. The handshaking lemma is a consequence of the degree sum formula (also sometimes called the handshaking lemma)

So we traverse all vertices, compute sum of sizes of their adjacency lists, and finally returns sum/2. Below implementation of above idea 




// C++ program to count number of edge in
// undirected graph
#include<bits/stdc++.h>
using namespace std;
 
// Adjacency list representation of graph
class Graph
{
    int V ;
    list < int > *adj;
public :
    Graph( int V )
    {
        this->V = V ;
        adj = new list<int>[V];
    }
    void addEdge ( int u, int v ) ;
    int countEdges () ;
};
 
// add edge to graph
void Graph :: addEdge ( int u, int v )
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Returns count of edge in undirected graph
int Graph :: countEdges()
{
    int sum = 0;
 
    //traverse all vertex
    for (int i = 0 ; i < V ; i++)
 
        // add all edge that are linked to the
        // current vertex
        sum += adj[i].size();
 
 
    // The count of edge is always even because in
    // undirected graph every edge is connected
    // twice between two vertices
    return sum/2;
}
 
// driver program to check above function
int main()
{
    int V = 9 ;
    Graph g(V);
 
    // making above shown graph
    g.addEdge(0, 1 );
    g.addEdge(0, 7 );
    g.addEdge(1, 2 );
    g.addEdge(1, 7 );
    g.addEdge(2, 3 );
    g.addEdge(2, 8 );
    g.addEdge(2, 5 );
    g.addEdge(3, 4 );
    g.addEdge(3, 5 );
    g.addEdge(4, 5 );
    g.addEdge(5, 6 );
    g.addEdge(6, 7 );
    g.addEdge(6, 8 );
    g.addEdge(7, 8 );
 
    cout << g.countEdges() << endl;
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to count number of edge in 


// undirected graph



import java.io.*;




import java.util.*;



 


// Adjacency list representation of graph



class Graph 



{



    int V;




    Vector<Integer>[] adj;



 



    //@SuppressWarnings("unchecked")




    Graph(int V)




    {




        this.V = V;




        this.adj = new Vector[V];



 



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




            adj[i] = new Vector<Integer>();




    }



 



    // add edge to graph




    void addEdge(int u, int v)




    {




        adj[u].add(v);




        adj[v].add(u);




    }



 



    // Returns count of edge in undirected graph




    int countEdges()




    {




        int sum = 0;



 



        // traverse all vertex




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



 



            // add all edge that are linked to the




            // current vertex




            sum += adj[i].size();



 



        // The count of edge is always even because in




        // undirected graph every edge is connected




        // twice between two vertices




        return sum / 2;




    }



}


 



class GFG 



{


 



    // Driver Code




    public static void main(String[] args) throws IOException 




    {




        int V = 9;




        Graph g = new Graph(V);



 



        // making above shown graph




        g.addEdge(0, 1);




        g.addEdge(0, 7);




        g.addEdge(1, 2);




        g.addEdge(1, 7);




        g.addEdge(2, 3);




        g.addEdge(2, 8);




        g.addEdge(2, 5);




        g.addEdge(3, 4);




        g.addEdge(3, 5);




        g.addEdge(4, 5);




        g.addEdge(5, 6);




        g.addEdge(6, 7);




        g.addEdge(6, 8);




        g.addEdge(7, 8);



 



        System.out.println(g.countEdges());




    }



}


 


// This code is contributed by


// sanjeev2552


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to count number of 


# edge in undirected graph 


 


# Adjacency list representation of graph 



class Graph:




    def __init__(self, V):




        self.V = V 




        self.adj = [[] for i in range(V)]



 



    # add edge to graph 




    def addEdge (self, u, v ):




        self.adj[u].append(v) 




        self.adj[v].append(u)




     



    # Returns count of edge in undirected graph 




    def countEdges(self):




        Sum = 0




     



        # traverse all vertex 




        for i in range(self.V):




     



            # add all edge that are linked 




            # to the current vertex 




            Sum += len(self.adj[i]) 




     



        # The count of edge is always even  




        # because in undirected graph every edge  




        # is connected twice between two vertices 




        return Sum // 2



 


# Driver Code



if __name__ == '__main__':




     



    V = 9




    g = Graph(V) 



 



    # making above shown graph 




    g.addEdge(0, 1 ) 




    g.addEdge(0, 7 ) 




    g.addEdge(1, 2 ) 




    g.addEdge(1, 7 ) 




    g.addEdge(2, 3 ) 




    g.addEdge(2, 8 ) 




    g.addEdge(2, 5 ) 




    g.addEdge(3, 4 ) 




    g.addEdge(3, 5 ) 




    g.addEdge(4, 5 ) 




    g.addEdge(5, 6 ) 




    g.addEdge(6, 7 ) 




    g.addEdge(6, 8 ) 




    g.addEdge(7, 8 ) 



 



    print(g.countEdges())



 


# This code is contributed by PranchalK


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program to count number of edge in 


// undirected graph



using System;




using System.Collections.Generic;



 


// Adjacency list representation of graph



class Graph 



{



    public int V;




    public List<int>[] adj;




    public Graph(int V)




    {




        this.V = V;




        this.adj = new List<int>[V];



 



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




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




    }



 



    // add edge to graph




    public void addEdge(int u, int v)




    {




        adj[u].Add(v);




        adj[v].Add(u);




    }



 



    // Returns count of edge in undirected graph




    public int countEdges()




    {




        int sum = 0;



 



        // traverse all vertex




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



 



            // add all edge that are linked to the




            // current vertex




            sum += adj[i].Count;



 



        // The count of edge is always even because in




        // undirected graph every edge is connected




        // twice between two vertices




        return sum / 2;




    }



}


 



class GFG 



{


 



    // Driver Code




    public static void Main(String[] args)




    {




        int V = 9;




        Graph g = new Graph(V);



 



        // making above shown graph




        g.addEdge(0, 1);




        g.addEdge(0, 7);




        g.addEdge(1, 2);




        g.addEdge(1, 7);




        g.addEdge(2, 3);




        g.addEdge(2, 8);




        g.addEdge(2, 5);




        g.addEdge(3, 4);




        g.addEdge(3, 5);




        g.addEdge(4, 5);




        g.addEdge(5, 6);




        g.addEdge(6, 7);




        g.addEdge(6, 8);




        g.addEdge(7, 8);



 



        Console.WriteLine(g.countEdges());




    }



}


 


// This code is contributed by PrinciRaj1992


















                        






                        























                                    



                                    




                                    




                                    


                                



















class Graph {



  constructor(V) {




    this.V = V;




    this.adj = new Array(V);




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




      this.adj[i] = [];




    }




  }



 



  addEdge(u, v) {




    this.adj[u].push(v);




    this.adj[v].push(u);




  }



 



  countEdges() {




    let sum = 0;




    for (let i = 0; i < this.V; i++) {




      sum += this.adj[i].length;




    }




    return sum / 2;




  }



}


 



function main() {




  let V = 9;




  let g = new Graph(V);




  g.addEdge(0, 1);




  g.addEdge(0, 7);




  g.addEdge(1, 2);




  g.addEdge(1, 7);




  g.addEdge(2, 3);




  g.addEdge(2, 8);




  g.addEdge(2, 5);




  g.addEdge(3, 4);




  g.addEdge(3, 5);




  g.addEdge(4, 5);




  g.addEdge(5, 6);




  g.addEdge(6, 7);




  g.addEdge(6, 8);




  g.addEdge(7, 8);




  console.log(g.countEdges());



}


 


main();


// this code is contributed by devendra


















                        






                        







Output:




14
Time Complexity: O(V)   

	

        Article Tags : 
        

            DSA
Graph        


	


      

      

          
Recommended Articles

      

      

          
          
1. What is Undirected Graph? | Undirected Graph meaning

          
2. Maximum number of edges among all connected components of an undirected graph

          
3. Minimum number of edges required to be removed from an Undirected Graph to make it acyclic

          
4. How to Generate a Random Undirected Graph for a Given Number of Edges in Java?

          
5. Minimum edges to be removed from given undirected graph to remove any existing path between nodes A and B

          
6. Ways to Remove Edges from a Complete Graph to make Odd Edges

          
7. Pendant Vertices, Non-Pendant Vertices, Pendant Edges and Non-Pendant Edges in Graph

          
8. Maximum number of edges that N-vertex graph can have such that graph is Triangle free | Mantel's Theorem

          
9. Convert the undirected graph into directed graph such that there is no path of length greater than 1

          
10. Convert undirected connected graph to strongly connected directed graph

          
11. Connect a graph by M edges such that the graph does not contain any cycle and Bitwise AND of connected vertices is maximum

          
12. Program to count Number of connected components in an undirected graph

          
13. Count the number of Prime Cliques in an undirected graph

          
14. Count total ways to reach destination from source in an undirected Graph

          
15. Count of unique lengths of connected components for an undirected graph using STL

          
16. Count of simple cycles in an undirected graph having N vertices

          
17. Count of nodes with maximum connection in an undirected graph

          
18. Count ways to change direction of edges such that graph becomes acyclic

          
19. Number of shortest paths in an Undirected Weighted Graph

          
20. Undirected graph splitting and its application for number pairs

          
21. Number of Triangles in an Undirected Graph

          
22. Number of single cycle components in an undirected graph

          
23. Program to find total number of edges in a Complete Graph

          
24. Number of Simple Graph with N Vertices and M Edges

          
25. Minimum number of edges between two vertices of a graph using DFS