Queue and Graph data structures + BFS algorithm were added

Author: FSou1

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = crlf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

README.md

@@ -1,6 +1,13 @@
 # TypeScript Algorithms and Data structures
 🔖 Algorithms and data structures implemented in TypeScript
 
+## Data structures
+
+A data structure is a data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.
+
+* [Queue](src/data-structures/queue) - a data structure to follow the FIFO principle;
+* [Graph](src/data-structures/graph) - a set of vertices and edges;
+
 ## Algorithms
 
 An algorithm is a finite sequence of well-defined, computer-implementable instructions, typically to solve a class of problems or to perform a computation.
@@ -18,6 +25,8 @@ An algorithm is a finite sequence of well-defined, computer-implementable instru
   * [Heapsort](/src/algorithms/sort/heapsort) - sort an array with a heapsort algorithm;
   * [Counting sort](/src/algorithms/sort/counting) - sort an array with a counting sort algorithm;
   * [Radix sort](/src/algorithms/sort/radix) - sort an array with a radix sort algorithm;
+* **Graph**
+  * [Breadth-first search](/src/algorithms/graph/breadth-first-search) - traverse a graph, explore neighbor vertices first;
 
 ## How to use this repository
 

src/algorithms/graph/breadth-first-search/README.md

@@ -0,0 +1,13 @@
+# Breadth-first search
+
+TBD.
+
+## Complexity
+
+**Time Complexity**: `O(|V| + |E|)` - since every vertex and every edge will be explored in the worst case, where |V| is the number of vertices and |E| is the number of edges in the graph;
+
+**Space Complexity**: `O(|V|)` - this is in addition to the space required for the graph itself, which may vary depending on the graph representation;
+
+## Referenes
+
+- [Youtube](https://www.youtube.com/watch?v=s-CYnVz-uh4);

src/algorithms/graph/breadth-first-search/__tests__/breadthFirstSearch.test.ts

@@ -0,0 +1,55 @@
+import {Graph} from '../../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../../data-structures/graph/graphVertex';
+import {GraphEdge} from '../../../../data-structures/graph/graphEdge';
+import {breadthFirstSearch} from '../breadthFirstSearch';
+
+test('should perform BFS on graph', () => {
+  const graph = new Graph(true);
+
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+  const vertexC = new GraphVertex('C');
+  const vertexD = new GraphVertex('D');
+  const vertexE = new GraphVertex('E');
+  const vertexF = new GraphVertex('F');
+  const vertexG = new GraphVertex('G');
+  const vertexH = new GraphVertex('H');
+
+  const edgeAB = new GraphEdge(vertexA, vertexB);
+  const edgeBC = new GraphEdge(vertexB, vertexC);
+  const edgeCG = new GraphEdge(vertexC, vertexG);
+  const edgeAD = new GraphEdge(vertexA, vertexD);
+  const edgeAE = new GraphEdge(vertexA, vertexE);
+  const edgeEF = new GraphEdge(vertexE, vertexF);
+  const edgeFD = new GraphEdge(vertexF, vertexD);
+  const edgeDH = new GraphEdge(vertexD, vertexH);
+  const edgeGH = new GraphEdge(vertexG, vertexH);
+
+  graph
+      .addEdge(edgeAB)
+      .addEdge(edgeBC)
+      .addEdge(edgeCG)
+      .addEdge(edgeAD)
+      .addEdge(edgeAE)
+      .addEdge(edgeEF)
+      .addEdge(edgeFD)
+      .addEdge(edgeDH)
+      .addEdge(edgeGH);
+
+  expect(graph.toString()).toBe('A,B,C,G,D,E,F,H');
+
+  const enterVertexCallback = jest.fn();
+  const leaveVertexCallback = jest.fn();
+
+  // Traverse graphs without callbacks first.
+  breadthFirstSearch(graph, vertexA);
+
+  // Traverse graph with enterVertex and leaveVertex callbacks.
+  breadthFirstSearch(graph, vertexA, {
+    enterVertex: enterVertexCallback,
+    leaveVertex: leaveVertexCallback,
+  });
+
+  expect(enterVertexCallback).toHaveBeenCalledTimes(8);
+  expect(leaveVertexCallback).toHaveBeenCalledTimes(8);
+});

src/algorithms/graph/breadth-first-search/breadthFirstSearch.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-unused-vars */
+import {Graph} from '../../../data-structures/graph/graph';
+import {GraphVertex} from '../../../data-structures/graph/graphVertex';
+import {GraphConfig} from '../../../data-structures/graph/graphConfig';
+import {Queue} from '../../../data-structures/queue/queue';
+
+/**
+ *
+ *
+ * @export
+ * @param {Graph} graph
+ * @param {GraphVertex} startVertex
+ * @param {GraphConfig} config
+ */
+export function breadthFirstSearch(
+    graph: Graph,
+    startVertex: GraphVertex,
+    config: GraphConfig = null,
+): void {
+  if (!graph) {
+    return;
+  }
+
+  if (!graph.getVertex(startVertex)) {
+    return;
+  }
+
+  config = initConfig(config);
+
+  const queue = new Queue<GraphVertex>();
+  queue.enqueue(startVertex);
+
+  while (!queue.isEmpty()) {
+    const currentVertex = queue.dequeue();
+    config.enterVertex(currentVertex);
+
+    const neighbors = currentVertex.getNeighbors();
+    for (const neighbor of neighbors) {
+      if (config.allowEnterVertex(neighbor)) {
+        queue.enqueue(neighbor);
+      }
+    }
+
+    config.leaveVertex(currentVertex);
+  }
+}
+
+/**
+ * @param {GraphConfig} config
+ * @return {GraphConfig}
+ */
+function initConfig(config: GraphConfig): GraphConfig {
+  config = config || ({} as GraphConfig);
+  config.enterVertex = config.enterVertex || ((vertex: GraphVertex) => {});
+  config.leaveVertex = config.leaveVertex || ((vertex: GraphVertex) => {});
+  config.allowEnterVertex = config.allowEnterVertex || isFirstEnter();
+  return config;
+}
+
+/**
+ * @param {GraphVertex} vertex
+ * @return {boolean}
+ */
+function isFirstEnter(): (vertex: GraphVertex) => boolean {
+  const visited = {};
+
+  return ((next: GraphVertex) => {
+    if (!visited[next.getKey()]) {
+      visited[next.getKey()] = true;
+      return true;
+    }
+
+    return false;
+  });
+}

src/data-structures/graph/README.md

@@ -0,0 +1,8 @@
+# Graph
+
+In mathematics, and more specifically in graph theory, a graph is a structure amounting to a set of objects in which some pairs of the objects are in some sense "related". The objects correspond to mathematical abstractions called vertices (also called nodes or points) and each of the related pairs of vertices is called an edge (also called link or line).
+
+## Referenes
+
+- [Youtube](https://www.youtube.com/watch?v=s-CYnVz-uh4);
+- [Wikipedia](https://en.wikipedia.org/wiki/Graph_(discrete_mathematics));

src/data-structures/graph/__test__/graph.test.ts

@@ -0,0 +1,46 @@
+import {Graph} from '../graph';
+import {GraphVertex} from '../graphVertex';
+
+test('an empty graph returns valid string', () => {
+  const graph = new Graph(false);
+  expect(graph.toString()).toBe('');
+});
+
+test('vertices can be added to graph', () => {
+  const graph = new Graph(false);
+
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+
+  graph
+      .addVertex(vertexA)
+      .addVertex(vertexB);
+
+  expect(graph.toString()).toBe('A,B');
+});
+
+test('existing vertex is returned', () => {
+  const graph = new Graph(false);
+
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+
+  graph
+      .addVertex(vertexA)
+      .addVertex(vertexB);
+
+  expect(graph.getVertex(vertexA)).toBe(vertexA);
+  expect(graph.getVertex(vertexB)).toBe(vertexB);
+});
+
+test('missing vertex is returned as null', () => {
+  const graph = new Graph(false);
+
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+
+  graph
+      .addVertex(vertexA);
+
+  expect(graph.getVertex(vertexB)).toBe(null);
+});

src/data-structures/graph/__test__/graphVertex.test.ts

@@ -0,0 +1,17 @@
+import {GraphVertex} from '../graphVertex';
+import {GraphEdge} from '../graphEdge';
+
+test('edges are added, neighbors are valid', () => {
+  const vertexA = new GraphVertex('A');
+  const vertexB = new GraphVertex('B');
+  const vertexC = new GraphVertex('C');
+
+  const edgeAB = new GraphEdge(vertexA, vertexB);
+  const edgeAC = new GraphEdge(vertexA, vertexC);
+
+  vertexA
+      .addEdge(edgeAB)
+      .addEdge(edgeAC);
+
+  expect(vertexA.getNeighbors()).toStrictEqual([vertexB, vertexC]);
+});

src/data-structures/graph/graph.ts

@@ -0,0 +1,88 @@
+/* eslint-disable no-unused-vars */
+import {GraphVertex} from './graphVertex';
+import {GraphEdge} from './graphEdge';
+
+/**
+ *
+ *
+ * @export
+ * @class Graph
+ */
+export class Graph {
+  directed: boolean;
+  verticies: {};
+
+  /**
+   * Creates an instance of Graph.
+   * @param {boolean} directed
+   * @memberof Graph
+   */
+  constructor(directed: boolean) {
+    this.directed = directed;
+    this.verticies = {};
+  }
+
+  /**
+   * Add a vertex to the graph
+   *
+   * @param {GraphVertex} vertex
+   * @return {Graph}
+   * @memberof Graph
+   */
+  addVertex(vertex: GraphVertex): Graph {
+    this.verticies[vertex.getKey()] = vertex;
+    return this;
+  }
+
+  /**
+   * @param {GraphEdge} edge
+   * @return {Graph}
+   * @memberof Graph
+   */
+  addEdge(edge: GraphEdge): Graph {
+    const start = edge.startVertex;
+    if (!this.getVertex(start)) {
+      this.addVertex(edge.startVertex);
+    }
+
+    const end = edge.endVertex;
+    if (!this.getVertex(end)) {
+      this.addVertex(edge.endVertex);
+    }
+
+    if (this.directed) {
+      this.getVertex(start).addEdge(edge);
+    } else {
+      this.getVertex(start).addEdge(edge);
+      this.getVertex(end).addEdge(edge);
+    }
+
+    return this;
+  }
+
+  /**
+   * @param {GraphVertex} vertex
+   * @return {GraphVertex}
+   * @memberof Graph
+   */
+  getVertex(vertex: GraphVertex): GraphVertex {
+    return this.verticies[vertex.getKey()] || null;
+  }
+
+  /**
+   * @param {GraphVertex} vertex
+   * @return {GraphVertex[]}
+   * @memberof Graph
+   */
+  getNeighbors(vertex: GraphVertex): GraphVertex[] {
+    return this.getVertex(vertex).getNeighbors();
+  }
+
+  /**
+   * @return {string}
+   * @memberof Graph
+   */
+  toString(): string {
+    return Object.keys(this.verticies).toString();
+  }
+}

src/data-structures/graph/graphConfig.ts

@@ -0,0 +1,25 @@
+// eslint-disable-next-line no-unused-vars
+import {GraphVertex} from './graphVertex';
+
+/**
+ *
+ *
+ * @export
+ * @class GraphConfig
+ */
+export class GraphConfig {
+  enterVertex: (vertex: GraphVertex) => void;
+  leaveVertex: (vertex: GraphVertex) => void;
+  allowEnterVertex?: (vertex: GraphVertex) => boolean;
+
+  /**
+   *Creates an instance of GraphConfig.
+   * @param {*} {enterVertex, leaveVertex, allowEnterVertex}
+   * @memberof GraphConfig
+   */
+  constructor({enterVertex, leaveVertex, allowEnterVertex}) {
+    this.enterVertex = enterVertex;
+    this.leaveVertex = leaveVertex;
+    this.allowEnterVertex = allowEnterVertex;
+  }
+}

src/data-structures/graph/graphEdge.ts

@@ -0,0 +1,24 @@
+// eslint-disable-next-line no-unused-vars
+import {GraphVertex} from './graphVertex';
+
+/**
+ *
+ *
+ * @export
+ * @class GraphEdge
+ */
+export class GraphEdge {
+  startVertex: GraphVertex;
+  endVertex: GraphVertex;
+
+  /**
+   *Creates an instance of GraphEdge.
+   * @param {GraphVertex} startVertex
+   * @param {GraphVertex} endVertex
+   * @memberof GraphEdge
+   */
+  constructor(startVertex: GraphVertex, endVertex: GraphVertex) {
+    this.startVertex = startVertex;
+    this.endVertex = endVertex;
+  }
+}