Skip to content

Commit

Permalink
Merge pull request #16 from diogofcunha/allow-initial-node-on-bfs
Browse files Browse the repository at this point in the history 
 feat: 🎸 allowed providing initial node for bfs and dfs
  • Loading branch information
@diogofcunha
diogofcunha authored Jan 21, 2024
2 parents b466b5f + 7546404 commit 5892370
Show file tree
Hide file tree
Showing 5 changed files with 384 additions and 14 deletions.
85 changes: 85 additions & 0 deletions src/__tests__/bfs.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,46 @@ describe("BFS Implementation unweighted graph", () => {
expect(visitedOrder).toEqual(expectedOrder);
});

test("BFS should visit all connected nodes in the correct order if initial is supplied", () => {
const graph = new Graph<number>();

const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG);
graph.addEdge(nodeG, nodeA);
graph.addEdge(nodeA, nodeB);
graph.addEdge(nodeA, nodeC);
graph.addEdge(nodeB, nodeD);
graph.addEdge(nodeC, nodeD);
graph.addEdge(nodeD, nodeE);

const visitedOrder: Array<string> = [];

graph.bfs(node => {
visitedOrder.push(node.id);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeB.id, nodeC.id, nodeD.id, nodeE.id];

expect(visitedOrder).toEqual(expectedOrder);
});

test("BFS should stop when break is returned", () => {
const graph = new Graph<number>();

Expand Down Expand Up @@ -92,12 +132,14 @@ describe("BFS Implementation weighted graph", () => {
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);
const nodeF = new Node<number>("F", 5);

graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);
graph.addNode(nodeF);

graph.addEdge(nodeA, nodeB, 1);
graph.addEdge(nodeA, nodeC, 2);
Expand All @@ -120,6 +162,49 @@ describe("BFS Implementation weighted graph", () => {
expect(costOrder).toEqual([0, 1, 2, 3, 5]);
});

test("BFS should visit all connected nodes in the correct order if initial is supplied", () => {
const graph = new Graph<number>({ weighted: true });

const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG, 1);
graph.addEdge(nodeG, nodeA, 1);
graph.addEdge(nodeA, nodeB, 1);
graph.addEdge(nodeA, nodeC, 2);
graph.addEdge(nodeB, nodeD, 3);
graph.addEdge(nodeC, nodeD, 4);
graph.addEdge(nodeD, nodeE, 5);

const visitedOrder: Array<string> = [];
const costOrder: Array<number | undefined> = [];

graph.bfs((node, cost) => {
visitedOrder.push(node.id);
costOrder.push(cost);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeB.id, nodeC.id, nodeD.id, nodeE.id];

expect(visitedOrder).toEqual(expectedOrder);
expect(costOrder).toEqual([0, 1, 2, 3, 5]);
});

test("BFS should stop when break is returned", () => {
const graph = new Graph<number>({ weighted: true });

Expand Down
87 changes: 87 additions & 0 deletions src/__tests__/bfsAsync.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,12 +9,14 @@ describe("BFS Async Implementation unweighted graph", () => {
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);
const nodeF = new Node<number>("E", 5);

graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);
graph.addNode(nodeF);

graph.addEdge(nodeA, nodeB);
graph.addEdge(nodeA, nodeC);
Expand All @@ -33,6 +35,46 @@ describe("BFS Async Implementation unweighted graph", () => {
expect(visitedOrder).toEqual(expectedOrder);
});

test("BFS should visit all connected nodes in the correct order if initial is supplied", () => {
const graph = new Graph<number>();

const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG);
graph.addEdge(nodeG, nodeA);
graph.addEdge(nodeA, nodeB);
graph.addEdge(nodeA, nodeC);
graph.addEdge(nodeB, nodeD);
graph.addEdge(nodeC, nodeD);
graph.addEdge(nodeD, nodeE);

const visitedOrder: Array<string> = [];

graph.bfs(node => {
visitedOrder.push(node.id);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeB.id, nodeC.id, nodeD.id, nodeE.id];

expect(visitedOrder).toEqual(expectedOrder);
});

test("BFS should stop when break is returned", async () => {
const graph = new Graph<number>();

Expand Down Expand Up @@ -92,12 +134,14 @@ describe("BFS Async Implementation weighted graph", () => {
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);
const nodeF = new Node<number>("E", 5);

graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);
graph.addNode(nodeF);

graph.addEdge(nodeA, nodeB, 1);
graph.addEdge(nodeA, nodeC, 2);
Expand All @@ -121,6 +165,49 @@ describe("BFS Async Implementation weighted graph", () => {
expect(costOrder).toEqual([0, 1, 2, 3, 5]);
});

test("BFS should visit all connected nodes in the correct order if initial is supplied", async () => {
const graph = new Graph<number>({ weighted: true });

const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG, 1);
graph.addEdge(nodeG, nodeA, 1);
graph.addEdge(nodeA, nodeB, 1);
graph.addEdge(nodeA, nodeC, 2);
graph.addEdge(nodeB, nodeD, 3);
graph.addEdge(nodeC, nodeD, 4);
graph.addEdge(nodeD, nodeE, 5);

const visitedOrder: Array<string> = [];
const costOrder: Array<number | undefined> = [];

await graph.bfsAsync(async (node, cost) => {
visitedOrder.push(node.id);
costOrder.push(cost);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeB.id, nodeC.id, nodeD.id, nodeE.id];

expect(visitedOrder).toEqual(expectedOrder);
expect(costOrder).toEqual([0, 1, 2, 3, 5]);
});

test("BFS should stop when break is returned", async () => {
const graph = new Graph<number>({ weighted: true });

Expand Down
79 changes: 79 additions & 0 deletions src/__tests__/dfs.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,44 @@ describe("DFS Implementation unweighted graphs", () => {
expect(visitedOrder).toEqual(expectedOrder);
});

test("DFS should visit all connected nodes in the correct order if initial is supplied", () => {
const graph = new Graph<number>();

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);
const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG);
graph.addEdge(nodeG, nodeA);
graph.addEdge(nodeA, nodeB);
graph.addEdge(nodeA, nodeC);
graph.addEdge(nodeB, nodeD);
graph.addEdge(nodeC, nodeD);
graph.addEdge(nodeD, nodeE);

const visitedOrder: Array<string> = [];
graph.dfs(node => {
visitedOrder.push(node.id);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeC.id, nodeD.id, nodeE.id, nodeB.id];

expect(visitedOrder).toEqual(expectedOrder);
});

test("DFS should stop when break is returned", () => {
const graph = new Graph<number>();

Expand Down Expand Up @@ -117,6 +155,47 @@ describe("DFS Implementation weighted graphs", () => {
expect(costOrder).toEqual([0, 2, 4, 5, 1]);
});

test("DFS should visit all connected nodes in the correct order if initial is supplied", () => {
const graph = new Graph<number>({ weighted: true });

const nodeA = new Node<number>("A", 1);
const nodeB = new Node<number>("B", 2);
const nodeC = new Node<number>("C", 3);
const nodeD = new Node<number>("D", 4);
const nodeE = new Node<number>("E", 5);
const nodeF = new Node<number>("F", 5);
const nodeG = new Node<number>("G", 5);

graph.addNode(nodeF);
graph.addNode(nodeG);
graph.addNode(nodeA);
graph.addNode(nodeB);
graph.addNode(nodeC);
graph.addNode(nodeD);
graph.addNode(nodeE);

graph.addEdge(nodeF, nodeG, 1);
graph.addEdge(nodeG, nodeA, 1);
graph.addEdge(nodeA, nodeB, 1);
graph.addEdge(nodeA, nodeC, 2);
graph.addEdge(nodeB, nodeD, 3);
graph.addEdge(nodeC, nodeD, 4);
graph.addEdge(nodeD, nodeE, 5);

const visitedOrder: Array<string> = [];
const costOrder: Array<number | undefined> = [];
graph.dfs((node, cost) => {
visitedOrder.push(node.id);
costOrder.push(cost);
return SearchAlgorithmNodeBehavior.continue;
}, nodeA);

const expectedOrder = [nodeA.id, nodeC.id, nodeD.id, nodeE.id, nodeB.id];

expect(visitedOrder).toEqual(expectedOrder);
expect(costOrder).toEqual([0, 2, 4, 5, 1]);
});

test("DFS should stop when break is returned", () => {
const graph = new Graph<number>({ weighted: true });

Expand Down
Loading

0 comments on commit 5892370

Please sign in to comment.