# Find if a degree sequence can form a simple graph | Havel-Hakimi Algorithm

• Difficulty Level : Basic
• Last Updated : 25 Aug, 2021

Given a sequence of non-negative integers arr[], the task is to check if there exists a simple graph corresponding to this degree sequence. Note that a simple graph is a graph with no self-loops and parallel edges.

Examples:

Input: arr[] = {3, 3, 3, 3}
Output: Yes
This is actually a complete graph(K4)

Input: arr[] = {3, 2, 1, 0}
Output: No
A vertex has degree n-1 so it’s connected to all the other n-1 vertices.
But another vertex has degree 0 i.e. isolated. It’s a contradiction.

Approach: One way to check the existence of a simple graph is by Havel-Hakimi algorithm given below:

• Sort the sequence of non-negative integers in non-increasing order.
• Delete the first element(say V). Subtract 1 from the next V elements.
• Repeat 1 and 2 until one of the stopping conditions is met.

Stopping conditions:

• All the elements remaining are equal to 0 (Simple graph exists).
• Negative number encounter after subtraction (No simple graph exists).
• Not enough elements remaining for the subtraction step (No simple graph exists).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function that returns true if``// a simple graph exists``bool` `graphExists(vector<``int``> &a, ``int` `n)``{``    ``// Keep performing the operations until one``    ``// of the stopping condition is met``    ``while` `(1)``    ``{``        ``// Sort the list in non-decreasing order``        ``sort(a.begin(), a.end(), greater<>());` `        ``// Check if all the elements are equal to 0``        ``if` `(a == 0)``            ``return` `true``;` `        ``// Store the first element in a variable``        ``// and delete it from the list``        ``int` `v = a;``        ``a.erase(a.begin() + 0);` `        ``// Check if enough elements``        ``// are present in the list``        ``if` `(v > a.size())``            ``return` `false``;` `        ``// Subtract first element from next v elements``        ``for` `(``int` `i = 0; i < v; i++)``        ``{``            ``a[i]--;` `            ``// Check if negative element is``            ``// encountered after subtraction``            ``if` `(a[i] < 0)``                ``return` `false``;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``vector<``int``> a = {3, 3, 3, 3};``    ``int` `n = a.size();` `    ``graphExists(a, n) ? cout << ``"Yes"` `:``                        ``cout << ``"NO"` `<< endl;` `    ``return` `0;``}` `// This code is contributed by``// sanjeev2552`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `@SuppressWarnings``(``"unchecked"``)` `class` `GFG{``  ` `// Function that returns true if``// a simple graph exists``static` `boolean` `graphExists(ArrayList a, ``int` `n)``{``    ` `    ``// Keep performing the operations until one``    ``// of the stopping condition is met``    ``while` `(``true``)``    ``{``        ` `        ``// Sort the list in non-decreasing order``        ``Collections.sort(a, Collections.reverseOrder());``         ` `        ``// Check if all the elements are equal to 0``        ``if` `((``int``)a.get(``0``) == ``0``)``            ``return` `true``;``   ` `        ``// Store the first element in a variable``        ``// and delete it from the list``        ``int` `v = (``int``)a.get(``0``);``        ``a.remove(a.get(``0``));``   ` `        ``// Check if enough elements``        ``// are present in the list``        ``if` `(v > a.size())``            ``return` `false``;``   ` `        ``// Subtract first element from``        ``// next v elements``        ``for``(``int` `i = ``0``; i < v; i++)``        ``{``            ``a.set(i, (``int``)a.get(i) - ``1``);``   ` `            ``// Check if negative element is``            ``// encountered after subtraction``            ``if` `((``int``)a.get(i) < ``0``)``                ``return` `false``;``        ``}``    ``}``}``  ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``ArrayList a = ``new` `ArrayList();``    ``a.add(``3``);``    ``a.add(``3``);``    ``a.add(``3``);``    ``a.add(``3``);``    ` `    ``int` `n = a.size();``     ` `    ``if` `(graphExists(a, n))``    ``{``        ``System.out.print(``"Yes"``);``    ``}``    ``else``    ``{``        ``System.out.print(``"NO"``);``    ``}``}``}` `// This code is contributed by pratham76`

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if``# a simple graph exists``def` `graphExists(a):` `    ``# Keep performing the operations until one``    ``# of the stopping condition is met``    ``while` `True``:` `        ``# Sort the list in non-decreasing order``        ``a ``=` `sorted``(a, reverse ``=` `True``)` `        ``# Check if all the elements are equal to 0``        ``if` `a[``0``]``=``=` `0` `and` `a[``len``(a)``-``1``]``=``=` `0``:``            ``return` `True` `        ``# Store the first element in a variable``        ``# and delete it from the list``        ``v ``=` `a[``0``]``        ``a ``=` `a[``1``:]` `        ``# Check if enough elements``        ``# are present in the list``        ``if` `v>``len``(a):``            ``return` `False` `        ``# Subtract first element from next v elements``        ``for` `i ``in` `range``(v):``            ``a[i]``-``=` `1` `            ``# Check if negative element is``            ``# encountered after subtraction``            ``if` `a[i]<``0``:``                ``return` `False`  `# Driver code``a ``=` `[``3``, ``3``, ``3``, ``3``]``if``(graphExists(a)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections;` `class` `GFG{`` ` `// Function that returns true if``// a simple graph exists``static` `bool` `graphExists(ArrayList a, ``int` `n)``{``    ` `    ``// Keep performing the operations until one``    ``// of the stopping condition is met``    ``while` `(``true``)``    ``{``        ` `        ``// Sort the list in non-decreasing order``        ``a.Sort();``        ``a.Reverse();``        ` `        ``// Check if all the elements are equal to 0``        ``if` `((``int``)a == 0)``            ``return` `true``;``  ` `        ``// Store the first element in a variable``        ``// and delete it from the list``        ``int` `v = (``int``)a;``        ``a.Remove(a);``  ` `        ``// Check if enough elements``        ``// are present in the list``        ``if` `(v > a.Count)``            ``return` `false``;``  ` `        ``// Subtract first element from``        ``// next v elements``        ``for``(``int` `i = 0; i < v; i++)``        ``{``            ``a[i] = (``int``)a[i] - 1;``  ` `            ``// Check if negative element is``            ``// encountered after subtraction``            ``if` `((``int``)a[i] < 0)``                ``return` `false``;``        ``}``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``ArrayList a = ``new` `ArrayList(){ 3, 3, 3, 3 };``    ``int` `n = a.Count;``    ` `    ``if` `(graphExists(a, n))``    ``{``        ``Console.Write(``"Yes"``);``    ``}``    ``else``    ``{``        ``Console.Write(``"NO"``);``    ``}``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O( )
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up