Algorithms:

[1] Simple BFS:

class Solution {
public:
// Function to return Breadth First Traversal of given graph.
vector<int> bfsOfGraph(int V, vector<int> adj[]) {
int vis[V] = {0};
vis[0] = 1;
queue<int> q;
// push the initial starting node
q.push(0);
vector<int> bfs;
// iterate till the queue is empty
while(!q.empty()) {
// get the topmost element in the queue
int node = q.front();
q.pop();
bfs.push_back(node);
// traverse for all its neighbours
for(auto it : adj[node]) {
// if the neighbour has previously not been visited,
// store in Q and mark as visited
if(!vis[it]) {
vis[it] = 1;
q.push(it);
}
}
}
return bfs;
}
};

[2]Simple DFS:

class Solution {
private:
void dfs(int node, vector<int> adj[], int vis[], vector<int>
&ls) {
vis[node] = 1;
 ls.push_back(node);
// traverse all its neighbours
for(auto it : adj[node]) {
// if the neighbour is not visited
if(!vis[it]) {
dfs(it, adj, vis, ls);
}
}
}

[3] Cycle detection (undirected graph) using bfs

class Solution {
private:
bool detect(int src, vector<int> adj[], int vis[]) {
vis[src] = 1;
// store <source node, parent node>
 queue<pair<int,int>> q;
q.push({src, -1});
// traverse until queue is not empty
while(!q.empty()) {
int node = q.front().first;
int parent = q.front().second;
q.pop();

// go to all adjacent nodes

for(auto adjacentNode: adj[node]) {
// if adjacent node is unvisited
if(!vis[adjacentNode]) {
vis[adjacentNode] = 1;
q.push({adjacentNode, node});
}
// if adjacent node is visited and is not it's own parent
node
else if(parent != adjacentNode) {
// yes it is a cycle
return true;
}
}
}
// there's no cycle
return false;
}

[4] cycle detection(undirected) dfs:

[5] cycle detection using dfs(directed graph):

class Solution {
 private:
bool dfsCheck(int node, vector<int> adj[], int vis[], int
pathVis[]) {
vis[node] = 1;
pathVis[node] = 1;

// traverse for adjacent nodes

for (auto it : adj[node]) {
// when the node is not visited
if (!vis[it]) {
if (dfsCheck(it, adj, vis, pathVis) ==
true)
return true;
}
// if the node has been previously visited
// but it has to be visited on the same path
else if (pathVis[it]) {
return true;
}
}

pathVis[node] = 0;
return false;
}

[6] bipartite graph using dfs:

class Solution {
private:
bool dfs(int node, int col, int color[], vector<int> adj[]) {
color[node] = col;

// traverse adjacent nodes

for(auto it : adj[node]) {
// if uncoloured
if(color[it] == -1) {
if(dfs(it, !col, color, adj) == false) return false;
}
// if previously coloured and have the same colour
else if(color[it] == col) {
return false;
 }
}

return true;
}
[7] bipartite graph using bfs:

bool bfs(vector<vector<int>>&adj,int start){

int n=adj.size();
vector<int>color(n,-1);

queue<int>q;
color[start]=0;
q.push(start);
while(!q.empty()){
int node=q.front();
q.pop();
for(auto nbr:adj[node]){
if(color[nbr]==-1){
color[nbr]=!color[node];
q.push(nbr);
}
else if(color[nbr]==color[node]){
return false;
}
}
}
return true;
}

[8] toposort using dfs:

class Solution {
private:
void dfs(int node, int vis[], stack<int> &st,
vector<int> adj[]) {
vis[node] = 1;
for (auto it : adj[node]) {
if (!vis[it]) dfs(it, vis, st, adj);
}
 st.push(node);
}

[9] toposort using bfs:

class Solution {
public:
//Function to return list containing vertices in Topological
order.
vector<int> topoSort(int V, vector<int> adj[])
{
int indegree[V] = {0};
for (int i = 0; i < V; i++) {
for (auto it : adj[i]) {
 indegree[it]++;
}
}

queue<int> q;
for (int i = 0; i < V; i++) {
if (indegree[i] == 0) {
q.push(i);
}
}
vector<int> topo;
while (!q.empty()) {
int node = q.front();
q.pop();
topo.push_back(node);
// node is in your topo sort
// so please remove it from the indegree

for (auto it : adj[node]) {

indegree[it]--;
if (indegree[it] == 0) q.push(it);
}
}

return topo;
}
};

[1] for a bipartite graph if nodes can be partitioned into two independent sets A and sets B such that
every edge in the graph connects a node A in set A and a node B in set B

-> no two adjacent nodes do not have same node

->if cycle length is even it is bipartite graph

-> if graph have no cycle than it is bipartite graph

-> odd length cycle is not bipartite graph

[2] Shortest cycle length in undirected cyclic graph:

To find shortest length we can’t find with normal dfs we have to use logic of directed graph cycle
detection otherwise go with bfs traversal with formula dist[node]+dist[nbr]+1;