The graph is a data structure that consists of vertices (or nodes) that can be connected to other vertices by edges.

The degree is the number of edges that are connected to a vertex, for example, the vertex A has a degree of 1 and the vertex C has a degree of 2.

Graphs can either directed or undirected, directed graphs are like a one-way street, undirected is like a two-way street.

Graphs can also have cycles.

Graphs might be a disconnected one, that means it consists of isolated subgraphs, or a connected one, in which all every pair of nodes are connected by an edge.

Graphs can be used to represent networks, websites structure, also used in path optimization algorithms, there are applications in other fields, such as linguistics, physics, chemistry, biology, mathematics, etc.

Representation

Graphs can be represented with

• Adjacency list - Every node stores a list of adjacent vertices, for example, an array or that contains all vertices and each vertex contains another array with adjacent vertices, other data structures can be used instead of an array, like a hash table and a linked list.

• Adjacency matrix - An NxN boolean matrix (where N is the number of vertices), if the matrix[i][j] stores the value true, there is a connection between the vertices i and j. In an undirected graph matrix[j][i] also will store the value true. You can use other types instead of boolean, for example, numbers to represent weight.

Graph Search

Depth-first search

Depth-first search is a way to navigate a graph, it starts from a given vertex and visits each branch completely before moving to another branch. DFS is often used when we need to visit every node in the graph.

Using DPS on the graph above the nodes will be visited in the following order: A, B, D, C, E, F.

Breadth-first search

This is another way to navigate a graph, it starts from a given vertex and visits all adjacent vertices before go to any of their children. BFS is useful to find a path between two nodes.

Using DPS on the graph above the nodes will be visited in the following order: A, B, E, F, D, C.

Bidirectional search

Consists of running two breadth-first searches simultaneously, each one starts from a different vertex and runs until they collide. This is useful to find the shortest path between two vertices.

Heres an implementation of a directed graph using a adjacency list, because it will perform better in almost all operations:

1export class Node<T> {
2  data: T;
3  adjacent: Node<T>[];
4  comparator: (a: T, b: T) => number;
5
6  constructor(data: T, comparator: (a: T, b: T) => number) {
7    this.data = data;
8    this.adjacent = [];
9    this.comparator = comparator;
10  }
11
12  addAdjacent(node: Node<T>): void {
13    this.adjacent.push(node);
14  }
15
16  removeAdjacent(data: T): Node<T> | null {
17    const index = this.adjacent.findIndex(
18      (node) => this.comparator(node.data, data) === 0
19    );
20
21    if (index > -1) {
22      return this.adjacent.splice(index, 1)[0];
23    }
24
25    return null;
26  }
27}
28
29class Graph<T> {
30  nodes: Map<T, Node<T>> = new Map();
31  comparator: (a: T, b: T) => number;
32
33  constructor(comparator: (a: T, b: T) => number) {
34    this.comparator = comparator;
35  }
36
37  /**
38   * Add a new node if it was not added before
39   *
40   * @param {T} data
41   * @returns {Node<T>}
42   */
43  addNode(data: T): Node<T> {
44    let node = this.nodes.get(data);
45
46    if (node) return node;
47
48    node = new Node(data, this.comparator);
49    this.nodes.set(data, node);
50
51    return node;
52  }
53
54  /**
55   * Remove a node, also remove it from other nodes adjacency list
56   *
57   * @param {T} data
58   * @returns {Node<T> | null}
59   */
60  removeNode(data: T): Node<T> | null {
61    const nodeToRemove = this.nodes.get(data);
62
63    if (!nodeToRemove) return null;
64
65    this.nodes.forEach((node) => {
66      node.removeAdjacent(nodeToRemove.data);
67    });
68
69    this.nodes.delete(data);
70
71    return nodeToRemove;
72  }
73
74  /**
75   * Create an edge between two nodes
76   *
77   * @param {T} source
78   * @param {T} destination
79   */
80  addEdge(source: T, destination: T): void {
81    const sourceNode = this.addNode(source);
82    const destinationNode = this.addNode(destination);
83
84    sourceNode.addAdjacent(destinationNode);
85  }
86
87  /**
88   * Remove an edge between two nodes
89   *
90   * @param {T} source
91   * @param {T} destination
92   */
93  removeEdge(source: T, destination: T): void {
94    const sourceNode = this.nodes.get(source);
95    const destinationNode = this.nodes.get(destination);
96
97    if (sourceNode && destinationNode) {
98      sourceNode.removeAdjacent(destination);
99    }
100  }
101
102  /**
103   * Depth-first search
104   *
105   * @param {T} data
106   * @param {Map<T, boolean>} visited
107   * @returns
108   */
109  private depthFirstSearchAux(node: Node<T>, visited: Map<T, boolean>): void {
110    if (!node) return;
111
112    visited.set(node.data, true);
113
114    console.log(node.data);
115
116    node.adjacent.forEach((item) => {
117      if (!visited.has(item.data)) {
118        this.depthFirstSearchAux(item, visited);
119      }
120    });
121  }
122
123  depthFirstSearch() {
124    const visited: Map<T, boolean> = new Map();
125    this.nodes.forEach((node) => {
126      if (!visited.has(node.data)) {
127        this.depthFirstSearchAux(node, visited);
128      }
129    });
130  }
131
132  /**
133   * Breadth-first search
134   *
135   * @param {T} data
136   * @returns
137   */
138  private breadthFirstSearchAux(node: Node<T>, visited: Map<T, boolean>): void {
139    const queue: Queue<Node<T>> = new Queue();
140
141    if (!node) return;
142
143    queue.add(node);
144    visited.set(node.data, true);
145
146    while (!queue.isEmpty()) {
147      node = queue.remove();
148
149      if (!node) continue;
150
151      console.log(node.data);
152
153      node.adjacent.forEach((item) => {
154        if (!visited.has(item.data)) {
155          visited.set(item.data, true);
156          queue.add(item);
157        }
158      });
159    }
160  }
161
162  breadthFirstSearch() {
163    const visited: Map<T, boolean> = new Map();
164    this.nodes.forEach((node) => {
165      if (!visited.has(node.data)) {
166        this.breadthFirstSearchAux(node, visited);
167      }
168    });
169  }
170}
171
172function comparator(a: number, b: number) {
173  if (a < b) return -1;
174
175  if (a > b) return 1;
176
177  return 0;
178}
179
180const graph = new Graph(comparator);