GeeksforGeeks App
Open App
Browser
Continue

# Check if the given graph represents a Star Topology

Given a graph G, the task is to check if it represents a Star Topology.
A Star Topology is the one shown in the image below:

Examples:

`Input : Graph = `

``` Output : YES

Input : Graph =```

`Output : NO`

A graph of V vertices represents a star topology if it satisfies the following three conditions:

1. One node (also called the central node) has degree V – 1.
2. All nodes except the central node have degree 1.
3. No of edges = No of Vertices – 1.

The idea is to traverse the graph and check if it satisfies the above three conditions. If yes, then it represents a Star Topology.

Below is the implementation of the above approach:

## C++

 `// CPP program to check if the given graph``// represents a Star Topology``#include ` `using` `namespace` `std;` `// A utility function to add an edge in an``// undirected graph.``void` `addEdge(vector<``int``> adj[], ``int` `u, ``int` `v)``{``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `// A utility function to print the adjacency list``// representation of graph``void` `printGraph(vector<``int``> adj[], ``int` `V)``{``    ``for` `(``int` `v = 0; v < V; ++v) {``        ``cout << ``"\n Adjacency list of vertex "``             ``<< v << ``"\n head "``;``        ``for` `(``auto` `x : adj[v])``            ``cout << ``"-> "` `<< x;``        ``printf``(``"\n"``);``    ``}``}` `/* Function to return true if the graph represented``   ``by the adjacency list represents a Star topology``   ``else return false */``bool` `checkStarTopologyUtil(vector<``int``> adj[], ``int` `V, ``int` `E)``{` `    ``// Number of edges should be equal``    ``// to (Number of vertices - 1)``    ``if` `(E != (V - 1))``        ``return` `false``;` `    ``// a single node is termed as a star topology``    ``// having only a central node``    ``if` `(V == 1)``        ``return` `true``;` `    ``int``* vertexDegree = ``new` `int``[V + 1];``    ``memset``(vertexDegree, 0, ``sizeof` `vertexDegree);` `    ``// calculate the degree of each vertex``    ``for` `(``int` `i = 1; i <= V; i++) {``        ``for` `(``auto` `v : adj[i]) {``            ``vertexDegree[v]++;``        ``}``    ``}` `    ``// countCentralNodes stores the count of nodes``    ``// with degree V - 1, which should be equal to 1``    ``// in case of star topology``    ``int` `countCentralNodes = 0, centralNode = 0;` `    ``for` `(``int` `i = 1; i <= V; i++) {``        ``if` `(vertexDegree[i] == (V - 1)) {``            ``countCentralNodes++;``            ``// Store the index of the central node``            ``centralNode = i;``        ``}``    ``}` `    ``// there should be only one central node``    ``// in the star topology``    ``if` `(countCentralNodes != 1)``        ``return` `false``;` `    ``for` `(``int` `i = 1; i <= V; i++) {``        ``// except for the central node``        ``// check if all other nodes have``        ``// degree 1, if not return false``        ``if` `(i == centralNode)``            ``continue``;``        ``if` `(vertexDegree[i] != 1) {``            ``return` `false``;``        ``}``    ``}` `    ``// if all three necessary``    ``// conditions as discussed,``    ``// satisfy return true``    ``return` `true``;``}` `// Function to check if the graph``// represents a Star topology``void` `checkStarTopology(vector<``int``> adj[], ``int` `V, ``int` `E)``{``    ``bool` `isStar = checkStarTopologyUtil(adj, V, E);``    ``if` `(isStar) {``        ``cout << ``"YES"` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"NO"` `<< endl;``    ``}``}` `// Driver code``int` `main()``{``    ``// Graph 1``    ``int` `V = 5, E = 4;``    ``vector<``int``> adj1[V + 1];``    ``addEdge(adj1, 1, 2);``    ``addEdge(adj1, 1, 3);``    ``addEdge(adj1, 1, 4);``    ``addEdge(adj1, 1, 5);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = 5, E = 4;``    ``vector<``int``> adj2[V + 1];``    ``addEdge(adj2, 1, 2);``    ``addEdge(adj2, 1, 3);``    ``addEdge(adj2, 3, 4);``    ``addEdge(adj2, 4, 5);``    ``checkStarTopology(adj2, V, E);` `    ``return` `0;``}`

## Java

 `// Java program to check if the given graph``// represents a star topology``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// A utility function to add an edge in an``  ``// undirected graph.``  ``static` `void` `addEdge(ArrayList> adj, ``int` `u, ``int` `v)``  ``{``    ``adj.get(u).add(v);``    ``adj.get(v).add(u);``  ``}` `  ``// A utility function to print the adjacency list``  ``// representation of graph``  ``static` `void` `printGraph(ArrayList> adj, ``int` `V)``  ``{``    ``for` `(``int` `v = ``0``; v < V; ++v)``    ``{``      ``System.out.print(``"\n Adjacency list of vertex "` `+``                       ``v + ``"\n head "``);``      ``for` `(``int` `x : adj.get(v))``      ``{``        ``System.out.print( ``"-> "` `+ x);``      ``}``      ``System.out.println();``    ``}``  ``}` `  ``/* Function to return true if the graph represented``    ``by the adjacency list represents a Star topology``    ``else return false */``  ``static` `boolean` `checkStarTopologyUtil(ArrayList> adj, ``int` `V, ``int` `E)``  ``{``    ``// Number of edges should be equal``    ``// to (Number of vertices - 1)``    ``if` `(E != (V - ``1``))``    ``{``      ``return` `false``;``    ``}` `    ``// a single node is termed as a star topology``    ``// having only a central node``    ``if` `(V == ``1``)``    ``{``      ``return` `true``;``    ``}``    ``int``[] vertexDegree = ``new` `int``[V + ``1``];` `    ``// calculate the degree of each vertex``    ``for` `(``int` `i = ``1``; i <= V; i++)``    ``{``      ``for` `(``int` `v : adj.get(i))``      ``{``        ``vertexDegree[v]++;``      ``}``    ``}` `    ``// countCentralNodes stores the count of nodes ``    ``// with degree V - 1, which should be equal to 1``    ``// in case of star topology``    ``int` `countCentralNodes = ``0``, centralNode = ``0``;    ``    ``for` `(``int` `i = ``1``; i <= V; i++)``    ``{``      ``if` `(vertexDegree[i] == (V - ``1``))``      ``{``        ``countCentralNodes++;` `        ``// Store the index of the central node``        ``centralNode = i;``      ``}``    ``}` `    ``// there should be only one central node``    ``// in the star topology``    ``if` `(countCentralNodes != ``1``)``      ``return` `false``;  ``    ``for` `(``int` `i = ``1``; i <= V; i++)``    ``{` `      ``// except for the central node ``      ``// check if all other nodes have``      ``// degree 1, if not return false``      ``if` `(i == centralNode)``        ``continue``;``      ``if` `(vertexDegree[i] != ``1``)``      ``{``        ``return` `false``;``      ``}``    ``}` `    ``// if all three necessary``    ``// conditions as discussed,``    ``// satisfy return true``    ``return` `true``;``  ``}` `  ``// Function to check if the graph ``  ``// represents a Star topology``  ``static` `void` `checkStarTopology(ArrayList> adj, ``int` `V, ``int` `E)``  ``{``    ``boolean` `isStar = checkStarTopologyUtil(adj, V, E);``    ``if` `(isStar)``    ``{``      ``System.out.println(``"YES"``);``    ``}``    ``else``    ``{``      ``System.out.println(``"NO"``);``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// Graph 1``    ``int` `V = ``5``, E = ``4``;``    ``ArrayList> adj1 =``      ``new` `ArrayList>();``    ``for``(``int` `i = ``0``; i < V + ``1``; i++)``    ``{``      ``adj1.add(``new` `ArrayList());``    ``}``    ``addEdge(adj1, ``1``, ``2``);``    ``addEdge(adj1, ``1``, ``3``);``    ``addEdge(adj1, ``1``, ``4``);``    ``addEdge(adj1, ``1``, ``5``);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = ``5``;``    ``E = ``4``;``    ``ArrayList> adj2 =``      ``new` `ArrayList>();``    ``for``(``int` `i = ``0``; i < (V + ``1``); i++)``    ``{``      ``adj2.add(``new` `ArrayList());``    ``}``    ``addEdge(adj2, ``1``, ``2``);``    ``addEdge(adj2, ``1``, ``3``);``    ``addEdge(adj2, ``3``, ``4``);``    ``addEdge(adj2, ``4``, ``5``);``    ``checkStarTopology(adj2, V, E);``  ``}``}` `// This code is contributed by rag2127`

## Python3

 `# Python3 program to check if the given graph``# represents a star topology` `# A utility function to add an edge in an``# undirected graph.``def` `addEdge(adj, u, v):``    ``adj[u].append(v)``    ``adj[v].append(u)` `# A utility function to print the adjacency list``# representation of graph``def` `printGraph(adj, V):` `    ``for` `v ``in` `range``(V):``        ``print``(``"Adjacency list of vertex "``,v,``"\n head "``)``        ``for` `x ``in` `adj[v]:``            ``print``(``"-> "``,x,end``=``" "``)``        ``printf()` `# /* Function to return true if the graph represented``#    by the adjacency list represents a star topology``#    else return false */``def` `checkStarTopologyUtil(adj, V, E):` `    ``# Number of edges should be equal``    ``# to (Number of vertices - 1)``    ``if` `(E !``=` `(V ``-` `1``)):``        ``return` `False` `    ``# a single node is termed as a bus topology``    ``if` `(V ``=``=` `1``):``        ``return` `True` `    ``vertexDegree ``=` `[``0``]``*``(V ``+` `1``)` `    ``# calculate the degree of each vertex``    ``for` `i ``in` `range``(V``+``1``):``        ``for` `v ``in` `adj[i]:``            ``vertexDegree[v] ``+``=` `1` `    ``# countCentralNodes stores the count of nodes``    ``# with degree V - 1, which should be equal to 1``    ``# in case of star topology``    ``countCentralNodes ``=` `0``    ``centralNode ``=` `0` `    ``for` `i ``in` `range``(``1``, V ``+` `1``):``        ``if` `(vertexDegree[i] ``=``=` `(V ``-` `1``)):``            ``countCentralNodes ``+``=` `1``            ``# Store the index of the central node``            ``centralNode ``=` `i` `    ``# there should be only one central node``    ``# in the star topology``    ``if` `(countCentralNodes !``=` `1``):``        ``return` `False` `    ``for` `i ``in` `range``(``1``, V ``+` `1``):``        ``# except for the central node``        ``# check if all other nodes have``        ``# degree 1, if not return false``        ``if` `(i ``=``=` `centralNode):``            ``continue``        ``if` `(vertexDegree[i] !``=` `1``):``            ``return` `False` `    ``# if all three necessary``    ``# conditions as discussed,``    ``# satisfy return true``    ``return` `True` `# Function to check if the graph represents a bus topology``def` `checkStarTopology(adj, V, E):` `    ``isStar ``=` `checkStarTopologyUtil(adj, V, E)``    ``if` `(isStar):``        ``print``(``"YES"``)` `    ``else``:``        ``print``(``"NO"` `)` `# Driver code` `# Graph 1``V, E ``=` `5``, ``4``adj1``=``[[] ``for` `i ``in` `range``(V ``+` `1``)]``addEdge(adj1, ``1``, ``2``)``addEdge(adj1, ``1``, ``3``)``addEdge(adj1, ``1``, ``4``)``addEdge(adj1, ``1``, ``5``)``checkStarTopology(adj1, V, E)` `# Graph 2``V, E ``=` `4``, ``4``adj2``=``[[] ``for` `i ``in` `range``(V ``+` `1``)]``addEdge(adj2, ``1``, ``2``)``addEdge(adj2, ``1``, ``3``)``addEdge(adj2, ``3``, ``4``)``addEdge(adj2, ``4``, ``2``)``checkStarTopology(adj2, V, E)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to check if the given graph``// represents a star topology``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// A utility function to add an edge in an``  ``// undirected graph.``  ``static` `void` `addEdge(List> adj, ``int` `u, ``int` `v)``  ``{``    ``adj[u].Add(v);``    ``adj[v].Add(u);``  ``}` `  ``// A utility function to print the adjacency list``  ``// representation of graph``  ``static` `void` `printGraph(List> adj, ``int` `V)``  ``{``    ``for` `(``int` `v = 0; v < V; ++v)``    ``{``      ``Console.WriteLine(``"\n Adjacency list of vertex "` `+ v + ``"\n head "``);``      ``foreach` `(``int` `x ``in` `adj[v])``      ``{``        ``Console.Write( ``"-> "` `+ x);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``/* Function to return true if the graph represented``    ``by the adjacency list represents a Star topology``    ``else return false */``  ``static` `bool` `checkStarTopologyUtil(List> adj, ``int` `V, ``int` `E)``  ``{``    ``// Number of edges should be equal``    ``// to (Number of vertices - 1)``    ``if` `(E != (V - 1))``    ``{``      ``return` `false``;``    ``}` `    ``// a single node is termed as a bus topology``    ``if` `(V == 1)``    ``{``      ``return` `true``;``    ``}``    ``int``[] vertexDegree = ``new` `int``[V + 1];` `    ``// calculate the degree of each vertex``    ``for` `(``int` `i = 1; i <= V; i++)``    ``{``      ``foreach` `(``int` `v ``in` `adj[i])``      ``{``        ``vertexDegree[v]++;``      ``}``    ``}` `    ``// countCentralNodes stores the count of nodes ``    ``// with degree V - 1, which should be equal to 1``    ``// in case of star topology``    ``int` `countCentralNodes = 0, centralNode = 0;    ``    ``for` `(``int` `i = 1; i <= V; i++)``    ``{``      ``if` `(vertexDegree[i] == (V - 1))``      ``{``        ``countCentralNodes++;` `        ``// Store the index of the central node``        ``centralNode = i;``      ``}``    ``}` `    ``// there should be only one central node``    ``// in the star topology``    ``if` `(countCentralNodes != 1)``      ``return` `false``;  ``    ``for` `(``int` `i = 1; i <= V; i++)``    ``{` `      ``// except for the central node ``      ``// check if all other nodes have``      ``// degree 1, if not return false``      ``if` `(i == centralNode)``        ``continue``;``      ``if` `(vertexDegree[i] != 1)``      ``{``        ``return` `false``;``      ``}``    ``}` `    ``// if all three necessary``    ``// conditions as discussed,``    ``// satisfy return true``    ``return` `true``;``  ``}` `  ``// Function to check if the graph ``  ``// represents a Star topology``  ``static` `void` `checkStarTopology(List> adj, ``int` `V, ``int` `E)``  ``{``    ``bool` `isStar = checkStarTopologyUtil(adj, V, E);``    ``if` `(isStar)``    ``{``      ``Console.WriteLine(``"YES"``);``    ``}``    ``else``    ``{``      ``Console.WriteLine(``"NO"``);``    ``}``  ``}` `  ``// Driver code``  ``static` `public` `void` `Main ()``  ``{` `    ``// Graph 1``    ``int` `V = 5, E = 4;``    ``List> adj1 = ``new` `List>();``    ``for``(``int` `i = 0; i < V + 1; i++)``    ``{``      ``adj1.Add(``new` `List<``int``>());``    ``}``    ``addEdge(adj1, 1, 2);``    ``addEdge(adj1, 1, 3);``    ``addEdge(adj1, 1, 4);``    ``addEdge(adj1, 1, 5);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = 5;``    ``E = 4;``    ``List> adj2 = ``new` `List>();``    ``for``(``int` `i = 0; i < V + 1; i++)``    ``{``      ``adj2.Add(``new` `List<``int``>());``    ``}``    ``addEdge(adj2, 1, 2);``    ``addEdge(adj2, 1, 3);``    ``addEdge(adj2, 3, 4);``    ``addEdge(adj2, 4, 4);``    ``checkStarTopology(adj2, V, E);``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output

```YES
NO```

Time Complexity: O(V + E) where V and E are the numbers of vertices and edges in the graph respectively.

Approach 2: Using DFS:

The DFS algorithm implemented in the code visits all the vertices in the graph, starting from a specified source vertex.

• The DFS function takes in a graph represented as an adjacency list (adj), the total number of vertices in the graph (V), and the starting vertex (s).
• The function starts by creating a boolean array visited of size V initialized to false which keeps track of whether a vertex has been visited or not.
• Then it initializes a stack stack and pushes the starting vertex s onto the stack.
• The function enters a loop where it pops the top element from the stack and checks whether it has been visited or not.
• If the vertex has not been visited, it marks it as visited and prints it.
• It then iterates through the adjacency list of the popped vertex v and pushes any unvisited neighbors onto the stack.
• The loop continues until the stack is empty, which means all vertices reachable from the starting vertex have been visited.

## C++

 `#include ``#include ` `using` `namespace` `std;` `// A utility function to add an edge in an undirected graph.``void` `addEdge(vector<``int``> adj[], ``int` `u, ``int` `v) {``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `// A utility function to print the adjacency list representation of graph``void` `printGraph(vector<``int``> adj[], ``int` `V) {``    ``for` `(``int` `v = 0; v < V; ++v) {``        ``cout << ``"Adjacency list of vertex "` `<< v << ``"\n head "``;``        ``for` `(``auto` `x : adj[v]) {``            ``cout << ``"-> "` `<< x << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `// A DFS function to traverse the graph and check for star topology``bool` `DFS(``int` `node, vector<``int``> adj[], vector<``bool``>& visited, vector<``int``>& degree, ``int` `V) {``    ``visited[node] = ``true``;``    ``degree[node] = adj[node].size();``    ``for` `(``int` `v : adj[node]) {``        ``if` `(!visited[v]) {``            ``DFS(v, adj, visited, degree, V);``        ``}``    ``}``    ` `    ``if` `(node != 0 && degree[node] != 1 && degree[node] != V-1) {``        ``// If a non-central node has a degree other than 1, it is not a star``        ``return` `false``;``    ``}``    ` `    ``if` `(node == 0 && degree[node] != V-1) {``        ``// If the central node does not have degree V-1, it is not a star``        ``return` `false``;``    ``}``    ` `    ``return` `true``;``}` `// Function to check if the graph represents a star topology``void` `checkStarTopology(vector<``int``> adj[], ``int` `V, ``int` `E) {``    ``vector<``bool``> visited(V, ``false``);``    ``vector<``int``> degree(V, 0);``    ` `    ``// Start DFS from node 0``    ``bool` `isStar = DFS(0, adj, visited, degree, V);``    ` `    ``if` `(isStar) {``        ``cout << ``"YES"` `<< endl;``    ``} ``else` `{``        ``cout << ``"NO"` `<< endl;``    ``}``}` `int` `main() {` `    ``// Graph 1``    ``int` `V = 5, E = 4;``    ``vector<``int``> adj1[V];``    ``addEdge(adj1, 0, 1);``    ``addEdge(adj1, 0, 2);``    ``addEdge(adj1, 0, 3);``    ``addEdge(adj1, 0, 4);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = 4, E = 4;``    ``vector<``int``> adj2[V];``    ``addEdge(adj2, 0, 1);``    ``addEdge(adj2, 0, 2);``    ``addEdge(adj2, 2, 3);``    ``addEdge(adj2, 3, 1);``    ``checkStarTopology(adj2, V, E);` `    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;``import` `java.util.Arrays;``import` `java.util.List;` `public` `class` `StarTopologyChecker {``  ``// A utility function to add an edge in an undirected graph.``static` `void` `addEdge(List[] adj, ``int` `u, ``int` `v) {``    ``adj[u].add(v);``    ``adj[v].add(u);``}` `// A utility function to print the adjacency list representation of graph``static` `void` `printGraph(List[] adj, ``int` `V) {``    ``for` `(``int` `v = ``0``; v < V; ++v) {``        ``System.out.print(``"Adjacency list of vertex "` `+ v + ``"\n head "``);``        ``for` `(``int` `x : adj[v]) {``            ``System.out.print(``"-> "` `+ x + ``" "``);``        ``}``        ``System.out.println();``    ``}``}` `// A DFS function to traverse the graph and check for star topology``static` `boolean` `DFS(``int` `node, List[] adj, ``boolean``[] visited, ``int``[] degree, ``int` `V) {``    ``visited[node] = ``true``;``    ``degree[node] = adj[node].size();``    ``for` `(``int` `v : adj[node]) {``        ``if` `(!visited[v]) {``            ``DFS(v, adj, visited, degree, V);``        ``}``    ``}``    ` `    ``if` `(node != ``0` `&& degree[node] != ``1` `&& degree[node] != V-``1``) {``        ``// If a non-central node has a degree other than 1, it is not a star``        ``return` `false``;``    ``}``    ` `    ``if` `(node == ``0` `&& degree[node] != V-``1``) {``        ``// If the central node does not have degree V-1, it is not a star``        ``return` `false``;``    ``}``    ` `    ``return` `true``;``}` `// Function to check if the graph represents a star topology``static` `void` `checkStarTopology(List[] adj, ``int` `V, ``int` `E) {``    ``boolean``[] visited = ``new` `boolean``[V];``    ``int``[] degree = ``new` `int``[V];``    ` `    ``// Start DFS from node 0``    ``boolean` `isStar = DFS(``0``, adj, visited, degree, V);``    ` `    ``if` `(isStar) {``        ``System.out.println(``"YES"``);``    ``} ``else` `{``        ``System.out.println(``"NO"``);``    ``}``}` `public` `static` `void` `main(String[] args) {``    ` `    ``// Graph 1``    ``int` `V = ``5``, E = ``4``;``    ``List[] adj1 = ``new` `ArrayList[V];``    ``for` `(``int` `i = ``0``; i < V; i++) {``        ``adj1[i] = ``new` `ArrayList<>();``    ``}``    ``addEdge(adj1, ``0``, ``1``);``    ``addEdge(adj1, ``0``, ``2``);``    ``addEdge(adj1, ``0``, ``3``);``    ``addEdge(adj1, ``0``, ``4``);``    ``checkStarTopology(adj1, V, E);``    ` `    ``// Graph 2``    ``V = ``4``; E = ``4``;``    ``List[] adj2 = ``new` `ArrayList[V];``    ``for` `(``int` `i = ``0``; i < V; i++) {``        ``adj2[i] = ``new` `ArrayList<>();``    ``}``    ``addEdge(adj2, ``0``, ``1``);``    ``addEdge(adj2, ``0``, ``2``);``    ``addEdge(adj2, ``2``, ``3``);``    ``addEdge(adj2, ``3``, ``1``);``    ``checkStarTopology(adj2, V, E);``}``}`

## Python3

 `# Python3 program to check if the given graph``# represents a star topology using DFS` `# A utility function to add an edge in an``# undirected graph.``def` `addEdge(adj, u, v):``    ``adj[u].append(v)``    ``adj[v].append(u)` `# A utility function to print the adjacency list``# representation of graph``def` `printGraph(adj, V):``    ``for` `v ``in` `range``(V):``        ``print``(``"Adjacency list of vertex "``,v,``"\n head "``)``        ``for` `x ``in` `adj[v]:``            ``print``(``"-> "``,x,end``=``" "``)``        ``printf()` `# A DFS function to traverse the graph and check for star topology``def` `DFS(node, adj, visited, degree, V):``    ``visited[node] ``=` `True``    ``degree[node] ``=` `len``(adj[node])``    ``for` `v ``in` `adj[node]:``        ``if` `not` `visited[v]:``            ``DFS(v, adj, visited, degree, V)``    ` `    ``if` `node !``=` `0` `and` `degree[node] !``=` `1` `and` `degree[node] !``=` `V``-``1``:``        ``# If a non-central node has a degree other than 1, it is not a star``        ``return` `False``    ` `    ``if` `node ``=``=` `0` `and` `degree[node] !``=` `V``-``1``:``        ``# If the central node does not have degree V-1, it is not a star``        ``return` `False``    ` `    ``return` `True` `# Function to check if the graph represents a star topology``def` `checkStarTopology(adj, V, E):``    ``visited ``=` `[``False``] ``*` `V``    ``degree ``=` `[``0``] ``*` `V``    ` `    ``# Start DFS from node 0``    ``isStar ``=` `DFS(``0``, adj, visited, degree, V)``    ` `    ``if` `isStar:``        ``print``(``"YES"``)``    ``else``:``        ``print``(``"NO"``)` `# Driver code` `# Graph 1``V, E ``=` `5``, ``4``adj1``=``[[] ``for` `i ``in` `range``(V)]``addEdge(adj1, ``0``, ``1``)``addEdge(adj1, ``0``, ``2``)``addEdge(adj1, ``0``, ``3``)``addEdge(adj1, ``0``, ``4``)``checkStarTopology(adj1, V, E)` `# Graph 2``V, E ``=` `4``, ``4``adj2``=``[[] ``for` `i ``in` `range``(V)]``addEdge(adj2, ``0``, ``1``)``addEdge(adj2, ``0``, ``2``)``addEdge(adj2, ``2``, ``3``)``addEdge(adj2, ``3``, ``1``)``checkStarTopology(adj2, V, E)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``// A utility function to add an edge in an undirected graph``static` `void` `addEdge(List<``int``>[] adj, ``int` `u, ``int` `v)``{``adj[u].Add(v);``adj[v].Add(u);``}``  ``// A utility function to print the adjacency list representation of graph``static` `void` `printGraph(List<``int``>[] adj, ``int` `V)``{``    ``for` `(``int` `v = 0; v < V; v++)``    ``{``        ``Console.Write(``"Adjacency list of vertex "` `+ v + ``"\n head "``);``        ``foreach` `(``int` `x ``in` `adj[v])``            ``Console.Write(``"-> "` `+ x);``        ``Console.WriteLine();``    ``}``}` `// A DFS function to traverse the graph and check for star topology``static` `bool` `DFS(``int` `node, List<``int``>[] adj, ``bool``[] visited, ``int``[] degree, ``int` `V)``{``    ``visited[node] = ``true``;``    ``degree[node] = adj[node].Count;``    ``foreach` `(``int` `v ``in` `adj[node])``    ``{``        ``if` `(!visited[v])``        ``{``            ``if` `(!DFS(v, adj, visited, degree, V))``                ``return` `false``;``        ``}``    ``}` `    ``if` `(node != 0 && degree[node] != 1 && degree[node] != V - 1)``    ``{``        ``// If a non-central node has a degree other than 1, it is not a star``        ``return` `false``;``    ``}` `    ``if` `(node == 0 && degree[node] != V - 1)``    ``{``        ``// If the central node does not have degree V-1, it is not a star``        ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Function to check if the graph represents a star topology``static` `void` `checkStarTopology(List<``int``>[] adj, ``int` `V, ``int` `E)``{``    ``bool``[] visited = ``new` `bool``[V];``    ``int``[] degree = ``new` `int``[V];` `    ``// Start DFS from node 0``    ``bool` `isStar = DFS(0, adj, visited, degree, V);` `    ``if` `(isStar)``        ``Console.WriteLine(``"YES"``);``    ``else``        ``Console.WriteLine(``"NO"``);``}` `// Driver code` `// Graph 1``static` `void` `Main(``string``[] args)``{``    ``int` `V = 5, E = 4;``    ``List<``int``>[] adj1 = ``new` `List<``int``>[V];``    ``for` `(``int` `i = 0; i < V; i++)``        ``adj1[i] = ``new` `List<``int``>();``    ``addEdge(adj1, 0, 1);``    ``addEdge(adj1, 0, 2);``    ``addEdge(adj1, 0, 3);``    ``addEdge(adj1, 0, 4);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = 4; E = 4;``    ``List<``int``>[] adj2 = ``new` `List<``int``>[V];``    ``for` `(``int` `i = 0; i < V; i++)``        ``adj2[i] = ``new` `List<``int``>();``    ``addEdge(adj2, 0, 1);``    ``addEdge(adj2, 0, 2);``    ``addEdge(adj2, 2, 3);``    ``addEdge(adj2, 3, 1);``    ``checkStarTopology(adj2, V, E);``}``}`

## Javascript

 `// Define a function to add an edge in an undirected graph.``function` `addEdge(adj, u, v) {``    ``adj[u].push(v);``    ``adj[v].push(u);``}` `// Define a function to print the adjacency list representation of graph.``function` `printGraph(adj, V) {``    ``for` `(let v = 0; v < V; ++v) {``        ``console.log(``"Adjacency list of vertex "` `+ v);``        ``let str = ``"head"``;``        ``for` `(let i = 0; i < adj[v].length; ++i) {``            ``str += ``" -> "` `+ adj[v][i];``        ``}``        ``console.log(str);``    ``}``}` `// Define a DFS function to traverse the graph and check for star topology.``function` `DFS(node, adj, visited, degree, V) {``    ``visited[node] = ``true``;``    ``degree[node] = adj[node].length;``    ``for` `(let v of adj[node]) {``        ``if` `(!visited[v]) {``            ``DFS(v, adj, visited, degree, V);``        ``}``    ``}``    ``if` `(node != 0 && degree[node] != 1 && degree[node] != V - 1) {``        ``// If a non-central node has a degree other than 1, it is not a star``        ``return` `false``;``    ``}` `    ``if` `(node == 0 && degree[node] != V - 1) {``        ``// If the central node does not have degree V-1, it is not a star``        ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Define a function to check if the graph represents a star topology.``function` `checkStarTopology(adj, V, E) {``    ``let visited = ``new` `Array(V).fill(``false``);``    ``let degree = ``new` `Array(V).fill(0); ``// Start DFS from node 0``    ``let isStar = DFS(0, adj, visited, degree, V);` `    ``if` `(isStar) {``        ``console.log(``"YES"``);``    ``} ``else` `{``        ``console.log(``"NO"``);``    ``}``}` `// Main function``function` `main() {` `    ``// Graph 1``    ``let V = 5,``        ``E = 4;``    ``let adj1 = ``new` `Array(V);``    ``for` `(let i = 0; i < V; ++i) {``        ``adj1[i] = [];``    ``}``    ``addEdge(adj1, 0, 1);``    ``addEdge(adj1, 0, 2);``    ``addEdge(adj1, 0, 3);``    ``addEdge(adj1, 0, 4);``    ``checkStarTopology(adj1, V, E);` `    ``// Graph 2``    ``V = 4, E = 4;``    ``let adj2 = ``new` `Array(V);``    ``for` `(let i = 0; i < V; ++i) {``        ``adj2[i] = [];``    ``}``    ``addEdge(adj2, 0, 1);``    ``addEdge(adj2, 0, 2);``    ``addEdge(adj2, 2, 3);``    ``addEdge(adj2, 3, 1);``    ``checkStarTopology(adj2, V, E);``}` `// Call the main function to execute the program.``main();`

Output

```YES
NO```

Time Complexity: O(V + E) where V and E are the numbers of vertices and edges in the graph respectively.

Auxiliary Space: O(V + E)

My Personal Notes arrow_drop_up