In computer science, a graph is an abstract data type that represents pairwise relationships between objects. A graph, in this context, consists of:

  • Vertices (or nodes): The fundamental units of a graph, representing discrete objects or concepts.
  • Edges: Lines or arcs that connect pairs of vertices, signifying a relationship between them. Edges can be:
    • Directed: Having an established direction from one vertex to another.
    • Undirected: Having no implied directionality.

Types of Graphs

Several common types of graphs exist:

  • Undirected Graph: Edges have no directionality (e.g., representing friendships on a social network).
  • Directed Graph (Digraph): Edges have a defined direction (e.g., modeling website links and their directions).
  • Weighted Graph: Edges carry a numerical value or "weight" representing aspects like cost, capacity, or distance (e.g., road networks).
  • Cyclic Graph: A graph containing at least one cycle (a path that starts and ends at the same vertex).
  • Acyclic Graph: A graph containing no cycles, often forming a tree-like structure.


Graphs are commonly represented using:

  • Adjacency Matrix: A two-dimensional matrix where rows and columns represent vertices, and cells indicate the presence or absence of an edge between the corresponding vertices.
  • Adjacency List: An array of linked lists where each list stores the neighbors of a vertex.


Numerous graph algorithms are essential in computer science:

  • Traversal Algorithms:
    • Breadth-First Search (BFS): Explores a graph level by level, starting from a source node.
    • Depth-First Search (DFS): Explores a graph by a path as far as possible before backtracking.
  • Shortest Path Algorithms:
    • Dijkstra's Algorithm: Finds the shortest path between a source and destination node in a weighted graph (with non-negative edge weights).
    • Bellman-Ford Algorithm: Finds shortest paths in weighted graphs, able to handle negative edge weights.
  • Minimum Spanning Tree Algorithms:
    • Kruskal's Algorithm: Constructs a tree within a graph that connects all vertices with the minimum total edge weight.
    • Prim's Algorithm: Builds a tree from a starting vertex and grows it by adding the cheapest possible edge in each step.


Graphs are a remarkably versatile data structure with a wide range of applications:

  • Networking: Representation of computer networks, communication patterns, and routing protocols.
  • Social Networks: Modeling relationships and interactions between people or groups.
  • Maps and Navigation: Representing roads, cities, and points of interest for pathfinding and routing.
  • Software Engineering: Modeling dependencies between components, state machines, and data flow.
  • Artificial Intelligence: Used in knowledge representation, decision-making, and planning problems.