Print nodes having maximum and minimum degrees

Given an undirected graph having N nodes, the task is to print the nodes having minimum and maximum degree.

Examples:

Input:
1-----2
|     |
3-----4
Output:
Nodes with maximum degree : 1 2 3 4 
Nodes with minimum degree : 1 2 3 4 
Every node has a degree of 2.

Input:
    1
   / \
  2   3
 /
4
Output:
Nodes with maximum degree : 1 2 
Nodes with minimum degree : 3 4

Approach: For an undirected graph, the degree of a node is the number of edges incident to it, so the degree of each node can be calculated by counting its frequency in the list of edges. Hence the approach is to use a map to calculate the frequency of every vertex from the edge list and use the map to find the nodes having maximum and minimum degrees.



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the nodes having
// maximum and minimum degree
void minMax(int edges[][2], int len, int n)
{
  
    // Map to store the degrees of every node
    map<int, int> m;
  
    for (int i = 0; i < len; i++) {
  
        // Storing the degree for each node
        m[edges[i][0]]++;
        m[edges[i][1]]++;
    }
  
    // maxi and mini variables to store
    // the maximum and minimum degree
    int maxi = 0;
    int mini = n;
  
    for (int i = 1; i <= n; i++) {
        maxi = max(maxi, m[i]);
        mini = min(mini, m[i]);
    }
  
    // Printing all the nodes with maximum degree
    cout << "Nodes with maximum degree : ";
    for (int i = 1; i <= n; i++) {
        if (m[i] == maxi)
            cout << i << " ";
    }
    cout << endl;
  
    // Printing all the nodes with minimum degree
    cout << "Nodes with minimum degree : ";
    for (int i = 1; i <= n; i++) {
        if (m[i] == mini)
            cout << i << " ";
    }
}
  
// Driver code
int main()
{
  
    // Count of nodes and edges
    int n = 4, m = 6;
  
    // The edge list
    int edges[][2] = { { 1, 2 },
                       { 1, 3 },
                       { 1, 4 },
                       { 2, 3 },
                       { 2, 4 },
                       { 3, 4 } };
  
    minMax(edges, m, 4);
  
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java implementation of the approach 


import java.util.*; 


  


class GFG  


{ 


  


// Function to print the nodes having 


// maximum and minimum degree 


static void minMax(int edges[][], int len, int n) 


{ 


  


    // Map to store the degrees of every node 


    HashMap<Integer, 


            Integer> m = new HashMap<Integer, 


                                     Integer>(); 


  


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


    { 


  


        // Storing the degree for each node 


        if(m.containsKey(edges[i][0])) 


        { 


            m.put(edges[i][0], m.get(edges[i][0]) + 1); 


        } 


        else


        { 


            m.put(edges[i][0], 1); 


        } 


        if(m.containsKey(edges[i][1])) 


        { 


            m.put(edges[i][1], m.get(edges[i][1]) + 1); 


        } 


        else


        { 


            m.put(edges[i][1], 1); 


        } 


    } 


  


    // maxi and mini variables to store 


    // the maximum and minimum degree 


    int maxi = 0; 


    int mini = n; 


  


    for (int i = 1; i <= n; i++)  


    { 


        maxi = Math.max(maxi, m.get(i)); 


        mini = Math.min(mini, m.get(i)); 


    } 


  


    // Printing all the nodes with maximum degree 


    System.out.print("Nodes with maximum degree : "); 


    for (int i = 1; i <= n; i++)  


    { 


        if (m.get(i) == maxi) 


            System.out.print(i + " "); 


    } 


    System.out.println(); 


  


    // Printing all the nodes with minimum degree 


    System.out.print("Nodes with minimum degree : "); 


    for (int i = 1; i <= n; i++) 


    { 


        if (m.get(i) == mini) 


            System.out.print(i + " "); 


    } 


} 


  


// Driver code 


public static void main(String[] args) 


{ 


    // Count of nodes and edges 


    int n = 4, m = 6; 


  


    // The edge list 


    int edges[][] = {{ 1, 2 }, { 1, 3 }, 


                     { 1, 4 }, { 2, 3 }, 


                     { 2, 4 }, { 3, 4 }}; 


  


    minMax(edges, m, 4); 


} 


} 


  


// This code is contributed by PrinciRaj1992 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 implementation of the approach 


  


# Function to print the nodes having  


# maximum and minimum degree  


def minMax(edges, leng, n) :  


  


    # Map to store the degrees of every node  


    m = {}; 


      


    for i in range(leng) : 


        m[edges[i][0]] = 0; 


        m[edges[i][1]] = 0; 


          


    for i in range(leng) : 


          


        # Storing the degree for each node 


        m[edges[i][0]] += 1; 


        m[edges[i][1]] += 1;  


  


    # maxi and mini variables to store  


    # the maximum and minimum degree  


    maxi = 0;  


    mini = n;  


  


    for i in range(1, n + 1) : 


        maxi = max(maxi, m[i]);  


        mini = min(mini, m[i]);  


  


    # Printing all the nodes  


    # with maximum degree  


    print("Nodes with maximum degree : ",  


                                end = "") 


      


    for i in range(1, n + 1) : 


        if (m[i] == maxi) : 


            print(i, end = " ");  


  


    print() 


  


    # Printing all the nodes  


    # with minimum degree  


    print("Nodes with minimum degree : ",  


                                end = "") 


      


    for i in range(1, n + 1) : 


        if (m[i] == mini) : 


            print(i, end = " ");  


  


# Driver code  


if __name__ == "__main__" :  


  


    # Count of nodes and edges  


    n = 4; m = 6;  


  


    # The edge list  


    edges = [[ 1, 2 ], [ 1, 3 ],  


             [ 1, 4 ], [ 2, 3 ],  


             [ 2, 4 ], [ 3, 4 ]];  


  


    minMax(edges, m, 4);  


  


# This code is contributed by AnkitRai01 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# implementation of the approach 


using System; 


using System.Collections.Generic; 


  


class GFG  


{ 


  


// Function to print the nodes having 


// maximum and minimum degree 


static void minMax(int [,]edges, int len, int n) 


{ 


  


    // Map to store the degrees of every node 


    Dictionary<int, int> m = new Dictionary<int, int>(); 


  


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


    { 


  


        // Storing the degree for each node 


        if(m.ContainsKey(edges[i, 0])) 


        { 


            m[edges[i, 0]] = m[edges[i, 0]] + 1; 


        } 


        else


        { 


            m.Add(edges[i, 0], 1); 


        } 


        if(m.ContainsKey(edges[i, 1])) 


        { 


            m[edges[i, 1]] = m[edges[i, 1]] + 1; 


        } 


        else


        { 


            m.Add(edges[i, 1], 1); 


        } 


    } 


  


    // maxi and mini variables to store 


    // the maximum and minimum degree 


    int maxi = 0; 


    int mini = n; 


  


    for (int i = 1; i <= n; i++)  


    { 


        maxi = Math.Max(maxi, m[i]); 


        mini = Math.Min(mini, m[i]); 


    } 


  


    // Printing all the nodes with maximum degree 


    Console.Write("Nodes with maximum degree : "); 


    for (int i = 1; i <= n; i++)  


    { 


        if (m[i] == maxi) 


            Console.Write(i + " "); 


    } 


    Console.WriteLine(); 


  


    // Printing all the nodes with minimum degree 


    Console.Write("Nodes with minimum degree : "); 


    for (int i = 1; i <= n; i++) 


    { 


        if (m[i] == mini) 


            Console.Write(i + " "); 


    } 


} 


  


// Driver code 


public static void Main(String[] args) 


{ 


    // Count of nodes and edges 


    int m = 6; 


  


    // The edge list 


    int [,]edges = {{ 1, 2 }, { 1, 3 }, 


                    { 1, 4 }, { 2, 3 }, 


                    { 2, 4 }, { 3, 4 }}; 


  


    minMax(edges, m, 4); 


} 


} 


  


// This code is contributed by 29AjayKumar 



















                        chevron_right







                        filter_none











Output:


Nodes with maximum degree : 1 2 3 4 
Nodes with minimum degree : 1 2 3 4








    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
DiptayanBiswas
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.