Open In App
Related Articles

Sum of degrees of all nodes of a undirected graph

Improve Article
Improve
Save Article
Save
Like Article
Like

Given an edge list of a graph we have to find the sum of degree of all nodes of a undirected graph. 
Example 
 

Examples: 
 

Input : edge list : (1, 2), (2, 3), (1, 4), (2, 4)  
Output : sum= 8

Brute force approach 
We will add the degree of each node of the graph and print the sum. 
 

C++




// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
 
// returns the sum of degree of all
// the nodes in a undirected graph
int count(int edges[][2], int len, int n)
{
    int degree[n + 1] = { 0 };
 
    // compute the degree of each node
    for (int i = 0; i < len; i++) {
 
        // increase the degree of the
        // nodes
        degree[edges[i][0]]++;
        degree[edges[i][1]]++;
    }
 
    // calculate the sum of degree
    int sum = 0;
    for (int i = 1; i <= n; i++)
        sum += degree[i];
 
    return sum;
}
 
// main function
int main()
{
    // the edge list
    int edges[][2] = { { 1, 2 },
                       { 2, 3 },
                       { 1, 4 },
                       { 2, 4 } };
    int len = sizeof(edges) / (sizeof(int) * 2), n = 4;
 
    // display the result
    cout << "sum = " << count(edges, len, n) << endl;
    return 0;
}


Java




// Java implementation of the approach
class GFG {
 
    // returns the sum of degree of all
    // the nodes in a undirected graph
    static int count(int edges[][], int len, int n)
    {
        int degree[] = new int[n + 1];
 
        // compute the degree of each node
        for (int i = 0; i < len; i++) {
 
            // increase the degree of the
            // nodes
            degree[edges[i][0]]++;
            degree[edges[i][1]]++;
        }
 
        // calculate the sum of degree
        int sum = 0;
        for (int i = 1; i <= n; i++)
            sum += degree[i];
 
        return sum;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        // the edge list
        int edges[][] = { { 1, 2 },
                          { 2, 3 },
                          { 1, 4 },
                          { 2, 4 } };
        int len = edges.length, n = 4;
 
        // display the result
        System.out.println("sum = " + count(edges, len, n));
    }
}
 
// This code has been contributed by 29AjayKumar


Python3




# Python 3 implementation of above approach
 
# returns the sum of degree of all
# the nodes in a undirected graph
def count(edges, len1, n):
    degree = [0 for i in range(n + 1)]
 
    # compute the degree of each node
    for i in range(len1):
        # increase the degree of the
        # nodes
        degree[edges[i][0]] += 1
        degree[edges[i][1]] += 1
 
    # calculate the sum of degree
    sum = 0
    for i in range(1, n + 1, 1):
        sum += degree[i]
 
    return sum
 
# main function
if __name__ == '__main__':
    # the edge list
    edges = [[1, 2], [2, 3], [1, 4], [2, 4]]
    len1 = len(edges)
    n = 4
 
    # display the result
    print("sum =", count(edges, len1, n))
     
# This code is contributed by
# Surendra_Gangwar


C#




// C# implementation of the approach
using System;
 
class GFG {
 
    // returns the sum of degree of all
    // the nodes in a undirected graph
    static int count(int[][] edges, int len, int n)
    {
        int[] degree = new int[n + 1];
 
        // compute the degree of each node
        for (int i = 0; i < len; i++) {
 
            // increase the degree of the
            // nodes
            degree[edges[i][0]]++;
            degree[edges[i][1]]++;
        }
 
        // calculate the sum of degree
        int sum = 0;
        for (int i = 1; i <= n; i++)
            sum += degree[i];
 
        return sum;
    }
 
    // Driver code
    public static void Main()
    {
        // the edge list
        int[][] edges = new int[][] { new int[] { 1, 2 },
                                      new int[] { 2, 3 },
                                      new int[] { 1, 4 },
                                      new int[] { 2, 4 } };
        int len = edges.Length, n = 4;
 
        // display the result
        Console.WriteLine("sum = " + count(edges, len, n));
    }
}
 
// This code has been contributed by Code_Mech.


Javascript




<script>
 
// Javascript implementation of above approach
 
// returns the sum of degree of all
// the nodes in a undirected graph
function count(edges, len, n)
{
    var degree = Array(n+1).fill(0);
 
    // compute the degree of each node
    for (var i = 0; i < len; i++) {
 
        // increase the degree of the
        // nodes
        degree[edges[i][0]]++;
        degree[edges[i][1]]++;
    }
 
    // calculate the sum of degree
    var sum = 0;
    for (var i = 1; i <= n; i++)
        sum += degree[i];
 
    return sum;
}
 
// main function
// the edge list
var edges = [ [ 1, 2 ],
                   [ 2, 3 ],
                   [ 1, 4 ],
                   [ 2, 4 ] ];
var len = edges.length, n = 4;
 
// display the result
document.write( "sum = " + count(edges, len, n));
 
// This code is contributed by rutvik_56.
</script>


PHP




<?php
// PHP implementation of above approach
 
// Returns the sum of degree of all
// the nodes in a undirected graph
function count1($edges, $len, $n)
{
    $degree = array_fill(0, $n + 1, 0);
 
    // compute the degree of each node
    for ($i = 0; $i < $len; $i++)
    {
 
        // increase the degree of the
        // nodes
        $degree[$edges[$i][0]]++;
        $degree[$edges[$i][1]]++;
    }
 
    // calculate the sum of degree
    $sum = 0;
    for ($i = 1; $i <= $n; $i++)
        $sum += $degree[$i];
 
    return $sum;
}
 
// Driver Code
 
// the edge list
$edges = array(array(1, 2),
               array(2, 3),
               array(1, 4),
               array(2, 4));
$len = count($edges);
$n = 4;
 
// display the result
echo "sum = " . count1($edges, $len, $n) . "\n";
 
// This code is contributed by mits
?>


Output

sum = 8







Space complexity: O(n) as it uses an array of size n+1 (degree array) to store the degree of each node. 

Time complexity: O(n) as it iterates through the edges array.
Efficient approach 
If we get the number of the edges in a directed graph then we can find the sum of degree of the graph. Let us consider an graph with no edges. If we add a edge we are increasing the degree of two nodes of graph by 1, so after adding each edge the sum of degree of nodes increases by 2, hence the sum of degree is 2*e. 
 

C++




// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
 
// returns the sum of degree of all
// the nodes in a undirected graph
int count(int edges[][2], int len)
{
    return 2 * len;
}
 
// main function
int main()
{
    // the edge list
    int edges[][2] = { { 1, 2 },
                       { 2, 3 },
                       { 1, 4 },
                       { 2, 4 } };
    int len = sizeof(edges) / (sizeof(int) * 2);
 
    // display the result
    cout << "sum = " << count(edges, len) << endl;
    return 0;
}


Java




// Java implementation for above approach
class GFG {
 
    // returns the sum of degree of all
    // the nodes in a undirected graph
    static int count(int edges[][], int len)
    {
        return 2 * len;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        // the edge list
        int edges[][] = { { 1, 2 },
                          { 2, 3 },
                          { 1, 4 },
                          { 2, 4 } };
        int len = edges.length;
 
        // display the result
        System.out.println("sum = " + count(edges, len));
    }
}
 
// This code contributed by Rajput-Ji


Python 3




# Python3 implementation of above approach
 
# returns the sum of degree of all
# the nodes in a undirected graph
def count(edges, length) :
     
    return 2 * length;
 
# Driver Code
if __name__ == "__main__" :
 
    # the edge list
    edges = [[ 1, 2 ],
             [ 2, 3 ],
             [ 1, 4 ],
             [ 2, 4 ]];
    length = len(edges);
 
    # display the result
    print("sum = ", count(edges, length));
 
# This code is contributed by Ryuga


C#




// C# implementation for above approach
using System;
 
class GFG {
 
    // returns the sum of degree of all
    // the nodes in a undirected graph
    static int count(int[, ] edges, int len)
    {
        return 2 * len;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        // the edge list
        int[, ] edges = { { 1, 2 },
                          { 2, 3 },
                          { 1, 4 },
                          { 2, 4 } };
        int len = edges.GetLength(0);
 
        // display the result
        Console.WriteLine("sum = " + count(edges, len));
    }
}
 
/* This code contributed by PrinciRaj1992 */


Javascript




<script>
 
// Javascript implementation of above approach
 
// returns the sum of degree of all
// the nodes in a undirected graph
function count(edges, len)
{
    return 2 * len;
}
 
// main function
// the edge list
var edges = [ [ 1, 2 ],
                   [ 2, 3 ],
                   [ 1, 4 ],
                   [ 2, 4 ] ];
var len = edges.length;
// display the result
document.write( "sum = " + count(edges, len));
 
</script>   


PHP




<?php
// PHP implementation of above approach
 
// returns the sum of degree of all
// the nodes in a undirected graph
function count1($edges, $len)
{
    return 2 * $len;
}
 
// Driver Code
 
// the edge list
$edges = array(array(1, 2),
               array(2, 3),
               array(1, 4),
               array(2, 4));
$len = sizeof($edges);
 
// display the result
echo "sum = " . count1($edges, $len) . "\n";
 
// This code is contributed
// by Akanksha Rai
?>


Output

sum = 8







Space complexity: O(1) 

Time complexity: O(1) 
 

Another approach(Naive Approach):

We can iterate through the edge list and count the degree of each node. This can be done by creating a dictionary that maps each node to its degree, and then summing up the degrees of all nodes.

  1. Create a variable sum and initialize it to 0.This variable will store the sum of degrees of all nodes in the graph and iterate over all nodes in the graph.
  2. The FOR loop iterates over all nodes in the graph, where N is the total number of nodes in the graph. For each node i, it counts the number of edges that are incident on i (i.e., that have i as one of their endpoints), by iterating over all edges in the edge list and checking if i is one of their endpoints. The degree of node i is equal to the number of such edges. The degree of node i is then added to the sum and return the sum of degrees of all nodes:
  3. Returns the sum calculated in the previous stepand in the main function, create an edge list and call the countDegrees function to find the sum of degrees of all nodes:

Here is the implementation of above approach

C++




#include <iostream>
#include <unordered_map>
using namespace std;
 
int countDegrees(int edges[][2], int len)
{
    // create a dictionary to store degrees of nodes
    unordered_map<int, int> degrees;
 
    // iterate over all edges and count the degree of each
    // node
    for (int i = 0; i < len; i++) {
        degrees[edges[i][0]]++;
        degrees[edges[i][1]]++;
    }
 
    // sum up the degrees of all nodes
    int sum = 0;
    for (auto d : degrees) {
        sum += d.second;
    }
 
    return sum;
}
 
// main function
int main()
{
    // the edge list
    int edges[][2]
        = { { 1, 2 }, { 2, 3 }, { 1, 4 }, { 2, 4 } };
    int len = sizeof(edges) / (sizeof(int) * 2);
 
    // display the result
    cout << "sum = " << countDegrees(edges, len) << endl;
    return 0;
}


Java




import java.util.HashMap;
import java.util.Map;
 
public class GFG {
 
    // Function to count the degrees of nodes in an edge list
    public static int countDegrees(int[][] edges) {
        // Create a HashMap to store degrees of nodes
        Map<Integer, Integer> degrees = new HashMap<>();
 
        // Iterate over all edges and count the degree of each node
        for (int[] edge : edges) {
            degrees.put(edge[0], degrees.getOrDefault(edge[0], 0) + 1);
            degrees.put(edge[1], degrees.getOrDefault(edge[1], 0) + 1);
        }
 
        // Sum up the degrees of all nodes
        int sum = 0;
        for (int degree : degrees.values()) {
            sum += degree;
        }
 
        return sum;
    }
 
    // Main function
    public static void main(String[] args) {
        // The edge list
        int[][] edges = { { 1, 2 }, { 2, 3 }, { 1, 4 }, { 2, 4 } };
 
        // Display the result
        System.out.println("sum = " + countDegrees(edges));
    }
}


Python3




from collections import defaultdict
 
def count_degrees(edges):
    degrees = defaultdict(int)
 
    # iterate over all edges and count the degree of each node
    for edge in edges:
        degrees[edge[0]] += 1
        degrees[edge[1]] += 1
 
    # sum up the degrees of all nodes
    total_degrees = sum(degrees.values())
 
    return total_degrees
 
# main function
def main():
    # the edge list
    edges = [[1, 2], [2, 3], [1, 4], [2, 4]]
 
    # display the result
    print("sum =", count_degrees(edges))
 
if __name__ == '__main__':
    main()


C#




using System;
using System.Collections.Generic;
 
namespace DegreeCounting
{
    class Program
    {
        static int CountDegrees(int[,] edges)
        {
            // Create a dictionary to store degrees of nodes
            Dictionary<int, int> degrees = new Dictionary<int, int>();
 
            // Iterate over all edges and count the degree of each node
            for (int i = 0; i < edges.GetLength(0); i++)
            {
                int node1 = edges[i, 0];
                int node2 = edges[i, 1];
 
                if (!degrees.ContainsKey(node1))
                    degrees[node1] = 0;
                if (!degrees.ContainsKey(node2))
                    degrees[node2] = 0;
 
                degrees[node1]++;
                degrees[node2]++;
            }
 
            // Sum up the degrees of all nodes
            int sum = 0;
            foreach (var degree in degrees.Values)
            {
                sum += degree;
            }
 
            return sum;
        }
 
        static void Main(string[] args)
        {
            // The edge list
            int[,] edges = {
                { 1, 2 }, { 2, 3 }, { 1, 4 }, { 2, 4 }
            };
 
            // Display the result
            Console.WriteLine("sum = " + CountDegrees(edges));
        }
    }
}


Javascript




// Function to count degrees of nodes in a graph
function countDegrees(edges) {
    // Create a dictionary to store degrees of nodes
    const degrees = new Map();
 
    // Iterate over all edges and count the degree of each node
    for (const [node1, node2] of edges) {
        // Count degrees for both nodes
        degrees.set(node1, (degrees.get(node1) || 0) + 1);
        degrees.set(node2, (degrees.get(node2) || 0) + 1);
    }
 
    // Sum up the degrees of all nodes
    let sum = 0;
    for (const degree of degrees.values()) {
        sum += degree;
    }
 
    return sum;
}
 
// Main function
function main() {
    // The edge list
    const edges = [[1, 2], [2, 3], [1, 4], [2, 4]];
 
    // Display the result
    console.log("sum =", countDegrees(edges));
}
 
// Call the main function to run the code
main();


Output

sum = 8







Time complexity: O(len), where len is the length of the edge list
Auxiliary Space: O(N), where N is the total number of nodes in the graph


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 03 Oct, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials