Check whether a given graph is Bipartite or not
Last Updated : 16 Apr, 2025
Given a graph with V vertices numbered from 0 to V-1 and a list of edges, determine whether the graph is bipartite or not.
Note: A bipartite graph is a type of graph where the set of vertices can be divided into two disjoint sets, say U and V, such that every edge connects a vertex in U to a vertex in V, there are no edges between vertices within the same set.
Example:
Input: V = 4, edges[][]= [[0, 1], [0, 2], [1, 2], [2, 3]]
Output: false
Explanation:
node 1 and node 2 have same color while coloringThe graph is not bipartite because no matter how we try to color the nodes using two colors, there exists a cycle of odd length (like 1–2–0–1), which leads to a situation where two adjacent nodes end up with the same color. This violates the bipartite condition, which requires that no two connected nodes share the same color.
Input: V = 4, edges[][] = [[0, 1], [1, 2], [2, 3]]
Output: true
Explanation:
The given graph can be colored in two colors so, it is a bipartite graph.
Using Breadth-First Search (BFS)
Checking if a graph is bipartite is like trying to color the graph using only two colors, so that no two adjacent vertices have the same color. One approach is to check whether the graph is 2-colorable or not using backtracking algorithm m coloring problem.
A common and efficient way to solve this is by using Breadth-First Search (BFS). The idea is to traverse the graph level by level and assign colors alternately to the vertices as we proceed.
Step-by-step approach:
- Start BFS from any uncolored vertex and assign it color 0.
- For each vertex, color its uncolored neighbors with the opposite color (1 if current is 0, and vice versa)
- Check if a neighbor already has the same color as the current vertex, return false (graph is not bipartite).
- If BFS completes without any conflicts, return true (graph is bipartite).
Below is the implementation of the above approach:
C++ //Driver Code Starts #include <bits/stdc++.h> using namespace std; vector<vector<int>> constructadj(int V, vector<vector<int>> &edges){ vector<vector<int>> adj(V); for(auto it:edges){ adj[it[0]].push_back(it[1]); adj[it[1]].push_back(it[0]); } return adj; } // Function to check if the graph is Bipartite using BFS //Driver Code Ends bool isBipartite(int V, vector<vector<int>> &edges) { // Vector to store colors of vertices. // Initialize all as -1 (uncolored) vector<int> color(V, -1); //create adjacency list vector<vector<int>> adj = constructadj(V,edges); // Queue for BFS queue<int> q; // Iterate through all vertices to handle disconnected graphs for(int i = 0; i < V; i++) { // If the vertex is uncolored, start BFS from it if(color[i] == -1) { // Assign first color (0) to the starting vertex color[i] = 0; q.push(i); // Perform BFS while(!q.empty()) { int u = q.front(); q.pop(); // Traverse all adjacent vertices for(auto &v : adj[u]) { // If the adjacent vertex is uncolored, // assign alternate color if(color[v] == -1) { color[v] = 1 - color[u]; q.push(v); } // If the adjacent vertex has the same color, // graph is not bipartite else if(color[v] == color[u]) { return false; } } } } } // If no conflicts in coloring, graph is bipartite //Driver Code Starts return true; } int main() { int V = 4; vector<vector<int>> edges = {{0, 1}, {0, 2}, {1, 2}, {2, 3}}; if(isBipartite(V, edges)) cout << "true"; else cout << "false"; return 0; } //Driver Code Ends //Driver Code Starts import java.util.*; class GfG { // Function to construct the adjacency list from edges static ArrayList<ArrayList<Integer>> constructadj(int V, int[][] edges) { ArrayList<ArrayList<Integer>> adj = new ArrayList<>(); for (int i = 0; i < V; i++) { adj.add(new ArrayList<>()); } for (int[] edge : edges) { int u = edge[0]; int v = edge[1]; adj.get(u).add(v); adj.get(v).add(u); } return adj; } // Function to check if the graph is Bipartite using BFS //Driver Code Ends static boolean isBipartite(int V,int[][] edges) { int[] color = new int[V]; Arrays.fill(color, -1); // create adjacency list ArrayList<ArrayList<Integer>> adj = constructadj(V,edges); for (int i = 0; i < V; i++) { if (color[i] == -1) { Queue<Integer> q = new LinkedList<>(); color[i] = 0; q.offer(i); while (!q.isEmpty()) { int u = q.poll(); for (int v : adj.get(u)) { if (color[v] == -1) { color[v] = 1 - color[u]; q.offer(v); } else if (color[v] == color[u]) { return false; // Conflict found } } } } //Driver Code Starts } return true; } public static void main(String[] args) { int V = 4; // Edges of the graph int[][] edges = {{0, 1}, {0, 2}, {1, 2}, {2, 3}}; // Check if the graph is bipartite System.out.println(isBipartite(V, edges)); } } //Driver Code Ends #Driver Code Starts from collections import deque # Function to construct the adjacency list from edges def constructadj(V, edges): adj = [[] for _ in range(V)] for edge in edges: u, v = edge adj[u].append(v) adj[v].append(u) return adj # Function to check if the graph is Bipartite using BFS #Driver Code Ends def isBipartite(V, adj): # Initialize all as uncolored color = [-1] * V # create adjacency list adj = constructadj(V,edges) for i in range(V): if color[i] == -1: color[i] = 0 q = deque([i]) while q: u = q.popleft() for v in adj[u]: if color[v] == -1: color[v] = 1 - color[u] q.append(v) elif color[v] == color[u]: return False # Conflict found #Driver Code Starts # No conflict, graph is bipartite return True if __name__ == "__main__": V = 4 edges = [[0, 1], [0, 2], [1, 2], [2, 3]] print("true" if isBipartite(V, edges) else "false") #Driver Code Ends //Driver Code Starts using System; using System.Collections.Generic; class GfG { public static List<List<int>> constructadj(int V, List<List<int>> edges) { List<List<int>> adj = new List<List<int>>(); for (int i = 0; i < V; i++) adj.Add(new List<int>()); foreach (var edge in edges) { int u = edge[0]; int v = edge[1]; adj[u].Add(v); adj[v].Add(u); } return adj; } //Driver Code Ends // Function to check if the graph is Bipartite using BFS public static bool IsBipartite(int V, List<List<int> > edges){ int[] color = new int[V]; // create adjacency list List<List<int>> adj = constructadj(V, edges); // Initialize all as -1 (uncolored) Array.Fill(color, -1); // Iterate through all vertices to handle // disconnected graphs for (int i = 0; i < V; i++) { // If the vertex is uncolored, start BFS from it if (color[i] == -1) { // Assign first color (0) color[i] = 0; Queue<int> q = new Queue<int>(); q.Enqueue(i); // Perform BFS while (q.Count > 0) { int u = q.Dequeue(); // Traverse all adjacent vertices foreach(int v in adj[u]){ // If the adjacent vertex is // uncolored, assign alternate color if (color[v] == -1) { color[v] = 1 - color[u]; q.Enqueue(v); } // If the adjacent vertex has the // same color, graph is not // bipartite else if (color[v] == color[u]) { return false; } } } } } // If no conflicts in coloring, graph is bipartite //Driver Code Starts return true; } static void Main(){ int V = 4; List<List<int>> edges = new List<List<int>> { new List<int>{0, 1}, new List<int>{0, 2}, new List<int>{1, 2}, new List<int>{2, 3} }; if (IsBipartite(V, edges)) Console.WriteLine("true"); else Console.WriteLine("false"); } } //Driver Code Ends //Driver Code Starts // Function to construct adjacency list from edges function constructadj(V, edges) { const adj = Array.from({ length: V }, () => []); for (const [u, v] of edges) { adj[u].push(v); adj[v].push(u); // undirected graph } return adj; } //Driver Code Ends function isBipartite(V, edges){ // Initialize all as -1 (uncolored) const color = Array(V).fill(-1); // create adjacency list let adj = constructadj(V,edges); // Iterate through all vertices to handle disconnected // graphs for (let i = 0; i < V; i++) { // If the vertex is uncolored, start BFS from it if (color[i] === -1) { // Assign first color (0) color[i] = 0; const queue = [ i ]; // Perform BFS while (queue.length > 0) { const u = queue.shift(); // Traverse all adjacent vertices for (let v of adj[u]) { // If the adjacent vertex is uncolored, // assign alternate color if (color[v] === -1) { color[v] = 1 - color[u]; queue.push(v); // Push to queue } // If the adjacent vertex has the same // color, graph is not bipartite else if (color[v] === color[u]) { return false; } } } } } // If no conflicts in coloring, graph is bipartite //Driver Code Starts return true; } // Driver Code const V = 4; const adj = Array.from({length : V}, () => []); let edges = [[0, 1], [0, 2], [1, 2], [2, 3]]; console.log(isBipartite(V, edges)); //Driver Code Ends Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges. This is because BFS explores each vertex and edge exactly once.
Auxiliary Space: O(V), The queue used in BFS, which can hold up to V vertices and The color array (or map), which stores the color for each vertex, We do not count the adjacency list in auxiliary space as it is necessary for representing the input graph.
Using Depth-First Search (DFS)
We can also check if a graph is bipartite using Depth-First Search (DFS). We need to color the graph with two colors such that no two adjacent vertices share the same color. We start from any uncolored vertex, assigning it a color (e.g., color 0). As we explore each vertex, we recursively color its uncolored neighbors with the another color. If we ever find a neighbor that shares the same color as the current vertex, we can simply conclude that the graph is not bipartite. If there is no conflict found after the traversal then the given graph is bipartite.
For implementation of DFS approach please refer to this article "Check if a given graph is Bipartite using DFS".
Related Article:
Similar Reads
Graph Theory Tutorial Graph Theory is a branch of mathematics that is concerned with the study of relationships between different objects. A graph is a collection of various vertexes also known as nodes, and these nodes are connected with each other via edges. In this tutorial, we have covered all the topics of Graph The
1 min read
Basics of Graph Theory
Graph and its representationsA Graph is a non-linear data structure consisting of vertices and edges. The vertices are sometimes also referred to as nodes and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph is composed of a set of vertices( V ) and a set of edges( E ). The graph is den
12 min read
Mathematics | Graph Theory Basics - Set 1A Graph is just a way to show connections between things. It is set of edges and vertices where each edge is associated with unordered pair of vertices. Graph is a data structure that is defined by two components :Node or Vertex: It is a point or joint between two lines like people, cities, or websi
5 min read
Types of Graphs with ExamplesA graph is a mathematical structure that represents relationships between objects by connecting a set of points. It is used to establish a pairwise relationship between elements in a given set. graphs are widely used in discrete mathematics, computer science, and network theory to represent relation
9 min read
Walks, Trails, Paths, Cycles and Circuits in GraphWalks, trails, paths, cycles, and circuits in a graph are sequences of vertices and edges with different properties. Some allow repetition of vertices and edges, while others do not. In this article, we will explore these concepts with examples.What is Walk?A walk in a graph is a sequence of vertice
6 min read
Graph measurements: length, distance, diameter, eccentricity, radius, centerA graph is defined as a set of points known as 'Vertices' and a line joining these points is known as 'Edges'. It is a set consisting of where 'V' is vertices and 'E' is edge. Vertices: {A, B, C, D, E, F} Edges: {{A, B}, {A, D}, {A, E}, {B, C}, {C, E}, {C, F}, {D, E}, {E, F}} Graph Measurements: The
5 min read
Articulation Points (or Cut Vertices) in a GraphGiven an undirected graph with V vertices and E edges (edges[][]), Your task is to return all the articulation points in the graph. If no such point exists, return {-1}.Note: An articulation point is a vertex whose removal, along with all its connected edges, increases the number of connected compon
15+ min read
Bridges in a graphGiven an undirected Graph, The task is to find the Bridges in this Graph. An edge in an undirected connected graph is a bridge if removing it disconnects the graph. For a disconnected undirected graph, the definition is similar, a bridge is an edge removal that increases the number of disconnected
15+ min read
Mathematics | Independent Sets, Covering and MatchingMathematics | Independent Sets, Covering and Matching1. Independent SetsA set of vertices I is called an independent set if no two vertices in set I are adjacent to each other in other words the set of non-adjacent vertices is called an independent set.It is also called a stable set.The parameter α0
5 min read
Dijkstra's Algorithm to find Shortest Paths from a Source to allGiven a weighted undirected graph represented as an edge list and a source vertex src, find the shortest path distances from the source vertex to all other vertices in the graph. The graph contains V vertices, numbered from 0 to V - 1.Note: The given graph does not contain any negative edge. Example
12 min read
Depth First Search or DFS for a GraphIn Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and
13 min read
Breadth First Search or BFS for a GraphGiven a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Tree
Introduction to Tree Data StructureTree data structure is a hierarchical structure that is used to represent and organize data in the form of parent child relationship. The following are some real world situations which are naturally a tree.Folder structure in an operating system.Tag structure in an HTML (root tag the as html tag) or
15+ min read
Prim’s Algorithm for Minimum Spanning Tree (MST)Prim’s algorithm is a Greedy algorithm like Kruskal's algorithm. This algorithm always starts with a single node and moves through several adjacent nodes, in order to explore all of the connected edges along the way.The algorithm starts with an empty spanning tree. The idea is to maintain two sets o
15+ min read
Kruskal’s Minimum Spanning Tree (MST) AlgorithmA minimum spanning tree (MST) or minimum weight spanning tree for a weighted, connected, and undirected graph is a spanning tree (no cycles and connects all vertices) that has minimum weight. The weight of a spanning tree is the sum of all edges in the tree. In Kruskal's algorithm, we sort all edges
9 min read
Huffman Coding | Greedy Algo-3Huffman coding is a lossless data compression algorithm. The idea is to assign variable-length codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The variable-length codes assigned to input characters are Prefix Codes, means the codes (
12 min read
Tree Traversal TechniquesTree Traversal techniques include various ways to visit all the nodes of the tree. Unlike linear data structures (Array, Linked List, Queues, Stacks, etc) which have only one logical way to traverse them, trees can be traversed in different ways. In this article, we will discuss all the tree travers
7 min read
Travelling Salesman Problem using Dynamic ProgrammingGiven a 2d matrix cost[][] of size n where cost[i][j] denotes the cost of moving from city i to city j. The task is to complete a tour from city 0 (0-based index) to all other cities such that we visit each city exactly once and then at the end come back to city 0 at minimum cost.Note the difference
15 min read
Special Graph
Eulerian Graphs
Matching
Coloring
Planar Graph
Directed Graphs
Degree Centrality (Centrality Measure)Degree In graph theory, the degree (or valency) of a vertex of a graph is the number of edges incident to the vertex, with loops counted twice.[1] The degree of a vertex v is denoted \deg(v) or \deg v. The maximum degree of a graph G, denoted by \Delta (G), and the minimum degree of a graph, denoted
5 min read
Check if a graph is Strongly, Unilaterally or Weakly connectedGiven an unweighted directed graph G as a path matrix, the task is to find out if the graph is Strongly Connected or Unilaterally Connected or Weakly Connected. Strongly Connected: A graph is said to be strongly connected if every pair of vertices(u, v) in the graph contains a path between each othe
12 min read
Strongly Connected ComponentsStrongly Connected Components (SCCs) are a fundamental concept in graph theory and algorithms. In a directed graph, a Strongly Connected Component is a subset of vertices where every vertex in the subset is reachable from every other vertex in the same subset by traversing the directed edges. Findin
15+ min read
Euler and Hamiltonian PathsEuler and Hamiltonian paths are fundamental concepts in graph theory, a branch of mathematics that studies the properties and applications of graphs. An Euler path visits every edge of a graph exactly once, while a Hamiltonian path visits every vertex exactly once. These paths have significant appli
8 min read
Tarjan's Algorithm to find Strongly Connected ComponentsA directed graph is strongly connected if there is a path between all pairs of vertices. A strongly connected component (SCC) of a directed graph is a maximal strongly connected subgraph. For example, there are 3 SCCs in the following graph: We have discussed Kosaraju's algorithm for strongly connec
15+ min read
Handshaking Lemma and Interesting Tree PropertiesIntroduction Trees are an important concept in graph theory, and understanding their properties is crucial in solving many graph-related problems. In this article, we will explore two important properties of trees - the Handshaking Lemma and interesting tree properties. What is Handshaking Lemma? Ha
5 min read
Group Theory
Group in Maths: Group TheoryGroup theory is one of the most important branches of abstract algebra which is concerned with the concept of the group. A group consists of a set equipped with a binary operation that satisfies four key properties: specifically, it includes property of closure, associativity, the existence of an id
13 min read
Homomorphism & Isomorphism of GroupWe can say that  "o" is the binary operation on set G if: G is a non-empty set & G * G = { (a,b) : a , b∈ G } and o : G * G --> G. Here, aob denotes the image of ordered pair (a,b) under the function/operation o.Example - "+" is called a binary operation on G (any non-empty set ) if & onl
7 min read
Group Isomorphisms and AutomorphismsIn the study of algebraic structures, group isomorphisms and automorphisms play a fundamental role. By defining internal symmetries inside a group (automorphisms) and when two groups have the same structure (isomorphisms), these ideas aid in our understanding of the structure and symmetry of groups.
7 min read
Mathematics | Rings, Integral domains and FieldsPrerequisite - Mathematics | Algebraic Structure Ring - Let addition (+) and Multiplication (.) be two binary operations defined on a non empty set R. Then R is said to form a ring w.r.t addition (+) and multiplication (.) if the following conditions are satisfied: (R, +) is an abelian group ( i.e c
7 min read