algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-11 06:04:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Make DFS and BFS search algorithms generic (fixes #4229) (#4230)

Browse Source
This commit is contained in:
Snir Turgeman
2023-08-13 09:29:26 +03:00
committed by GitHub
parent 1ef700e850
commit 18848574be
6 changed files with 245 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pom.xml
View File

@ -38,7 +38,9 @@
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>${assertj.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>

32
src/main/java/com/thealgorithms/datastructures/Node.java Normal file
View File

@ -0,0 +1,32 @@
package com.thealgorithms.datastructures;
import java.util.ArrayList;
import java.util.List;
public class Node<T> {
private final T value;
private final List<Node<T>> children;
public Node(final T value) {
this.value = value;
this.children = new ArrayList<>();
}
public Node(final T value, final List<Node<T>> children) {
this.value = value;
this.children = children;
}
public T getValue() {
return value;
}
public void addChild(Node<T> child) {
children.add(child);
}
public List<Node<T>> getChildren() {
return children;
}
}

35
src/main/java/com/thealgorithms/searches/BreadthFirstSearch.java
View File

@ -1,32 +1,45 @@
package com.thealgorithms.searches;
import com.thealgorithms.searches.DepthFirstSearch.Node;
import java.util.ArrayDeque;
import java.util.Optional;
import java.util.Queue;
import com.thealgorithms.datastructures.Node;
import java.util.*;
/**
* @author: caos321
* @date: 31 October 2021 (Sunday)
* @wiki: https://en.wikipedia.org/wiki/Breadth-first_search
*/
public class BreadthFirstSearch {
public static Optional<Node> search(final Node node, final String name) {
if (node.getName().equals(name)) {
public class BreadthFirstSearch<T> {
private final List<T> visited = new ArrayList<>();
public Optional<Node<T>> search(final Node<T> node, final T value) {
if (node == null) {
return Optional.empty();
}
if (node.getValue().equals(value)) {
// add root node to visited
visited.add(value);
return Optional.of(node);
}
visited.add(node.getValue());
Queue<Node> queue = new ArrayDeque<>(node.getSubNodes());
Queue<Node<T>> queue = new ArrayDeque<>(node.getChildren());
while (!queue.isEmpty()) {
final Node current = queue.poll();
final Node<T> current = queue.poll();
visited.add(current.getValue());
if (current.getName().equals(name)) {
if (current.getValue().equals(value)) {
return Optional.of(current);
}
queue.addAll(current.getSubNodes());
queue.addAll(current.getChildren());
}
return Optional.empty();
}
public List<T> getVisited() {
return visited;
}
}

71
src/main/java/com/thealgorithms/searches/DepthFirstSearch.java
View File

@ -1,79 +1,32 @@
package com.thealgorithms.searches;
import com.thealgorithms.datastructures.Node;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
/**
* @author: caos321
* @date: 31 October 2021 (Sunday)
* @wiki: https://en.wikipedia.org/wiki/Depth-first_search
*/
public class DepthFirstSearch {
public class DepthFirstSearch<T> {
static class Node {
private final List<T> visited = new ArrayList<>();
private final String name;
private final List<Node> subNodes;
public Node(final String name) {
this.name = name;
this.subNodes = new ArrayList<>();
public Optional<Node<T>> recursiveSearch(final Node<T> node, final Integer value) {
if (node == null) {
return Optional.empty();
}
public Node(final String name, final List<Node> subNodes) {
this.name = name;
this.subNodes = subNodes;
}
public String getName() {
return name;
}
public List<Node> getSubNodes() {
return subNodes;
}
}
public static Optional<Node> search(final Node node, final String name) {
if (node.getName().equals(name)) {
visited.add(node.getValue());
if (node.getValue().equals(value)) {
return Optional.of(node);
}
return node.getSubNodes().stream().map(value -> search(value, name)).flatMap(Optional::stream).findAny();
return node.getChildren().stream().map(v -> recursiveSearch(v, value)).flatMap(Optional::stream).findAny();
}
public static void assertThat(final Object actual, final Object expected) {
if (!Objects.equals(actual, expected)) {
throw new AssertionError(String.format("expected=%s but was actual=%s", expected, actual));
}
}
public static void main(final String[] args) {
final Node rootNode = new Node("A", List.of(new Node("B", List.of(new Node("D"), new Node("F", List.of(new Node("H"), new Node("I"))))), new Node("C", List.of(new Node("G"))), new Node("E")));
{
final String expected = "I";
final Node result = search(rootNode, expected).orElseThrow(() -> new AssertionError("Node not found!"));
assertThat(result.getName(), expected);
}
{
final String expected = "G";
final Node result = search(rootNode, expected).orElseThrow(() -> new AssertionError("Node not found!"));
assertThat(result.getName(), expected);
}
{
final String expected = "E";
final Node result = search(rootNode, expected).orElseThrow(() -> new AssertionError("Node not found!"));
assertThat(result.getName(), expected);
}
public List<T> getVisited() {
return visited;
}
}

100
src/test/java/com/thealgorithms/searches/BreadthFirstSearchTest.java
View File

@ -2,33 +2,101 @@ package com.thealgorithms.searches;
import static org.junit.jupiter.api.Assertions.*;
import com.thealgorithms.datastructures.Node;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class BreadthFirstSearchTest {
public class BreadthFirstSearchTest {
private Node<String> root;
private BreadthFirstSearch<String> bfs;
private static final DepthFirstSearch.Node rootNode = new DepthFirstSearch.Node("A",
List.of(new DepthFirstSearch.Node("B", List.of(new DepthFirstSearch.Node("D"), new DepthFirstSearch.Node("F", List.of(new DepthFirstSearch.Node("H"), new DepthFirstSearch.Node("I"))))), new DepthFirstSearch.Node("C", List.of(new DepthFirstSearch.Node("G"))), new DepthFirstSearch.Node("E")));
// Tree structure:
//
// A
// / | \
// B C D
// / \
// E F
@Test
void searchI() {
Optional<DepthFirstSearch.Node> Inode = BreadthFirstSearch.search(rootNode, "I");
assertTrue(Inode.isPresent());
assertEquals(Inode.get().getName(), "I");
@BeforeEach
public void setUp() {
// nodes declaration
root = new Node<>("A");
var nodeB = new Node<>("B");
var nodeC = new Node<>("C");
var nodeD = new Node<>("D");
var nodeE = new Node<>("E");
var nodeF = new Node<>("F");
// tree initialization
root.addChild(nodeB);
root.addChild(nodeC);
root.addChild(nodeD);
nodeB.addChild(nodeE);
nodeB.addChild(nodeF);
// create an instance to monitor the visited nodes
bfs = new BreadthFirstSearch<>();
}
@Test
void searchG() {
Optional<DepthFirstSearch.Node> Gnode = BreadthFirstSearch.search(rootNode, "G");
assertTrue(Gnode.isPresent());
assertEquals(Gnode.get().getName(), "G");
public void testSearchRoot() {
String expectedValue = "A";
List<String> expectedPath = List.of("A");
// check value
Optional<Node<String>> value = bfs.search(root, expectedValue);
assertEquals(expectedValue, value.orElse(new Node<>("")).getValue());
// check path
assertArrayEquals(expectedPath.toArray(), bfs.getVisited().toArray());
}
@Test
void searchE() {
Optional<DepthFirstSearch.Node> Enode = BreadthFirstSearch.search(rootNode, "E");
assertTrue(Enode.isPresent());
assertEquals(Enode.get().getName(), "E");
public void testSearchF() {
String expectedValue = "F";
List<String> expectedPath = List.of("A", "B", "C", "D", "E", "F");
// check value
Optional<Node<String>> value = Optional.of(bfs.search(root, expectedValue).orElse(new Node<>(null)));
assertEquals(expectedValue, value.get().getValue());
// check path
assertArrayEquals(expectedPath.toArray(), bfs.getVisited().toArray());
}
@Test
void testSearchNull() {
List<String> expectedPath = List.of("A", "B", "C", "D", "E", "F");
Optional<Node<String>> node = bfs.search(root, null);
// check value
assertTrue(node.isEmpty());
// check path
assertArrayEquals(expectedPath.toArray(), bfs.getVisited().toArray());
}
@Test
void testNullRoot() {
var value = bfs.search(null, "B");
assertTrue(value.isEmpty());
}
@Test
void testSearchValueThatNotExists() {
List<String> expectedPath = List.of("A", "B", "C", "D", "E", "F");
var value = bfs.search(root, "Z");
// check that the value is empty because it's not exists in the tree
assertTrue(value.isEmpty());
// check path is the whole list
assertArrayEquals(expectedPath.toArray(), bfs.getVisited().toArray());
}
}

91
src/test/java/com/thealgorithms/searches/DepthFirstSearchTest.java Normal file
View File

@ -0,0 +1,91 @@
package com.thealgorithms.searches;
import static org.junit.jupiter.api.Assertions.*;
import com.thealgorithms.datastructures.Node;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class DepthFirstSearchTest {
private Node<Integer> root;
private DepthFirstSearch<Integer> dfs;
//
// Tree structure:
// 1
// / | \
// 2 3 4
// / \
// 5 6
@BeforeEach
public void setUp() {
// nodes declaration
root = new Node<>(1);
var nodeB = new Node<>(2);
var nodeC = new Node<>(3);
var nodeD = new Node<>(4);
var nodeE = new Node<>(5);
var nodeF = new Node<>(6);
// tree initialization
root.addChild(nodeB);
root.addChild(nodeC);
root.addChild(nodeD);
nodeB.addChild(nodeE);
nodeB.addChild(nodeF);
// create an instance to monitor the visited nodes
dfs = new DepthFirstSearch<>();
}
@Test
public void testSearchRoot() {
Integer expectedValue = 1;
List<Integer> expectedPath = List.of(1);
// check value
Optional<Node<Integer>> value = dfs.recursiveSearch(root, expectedValue);
assertEquals(expectedValue, value.orElse(new Node<>(null)).getValue());
// check path
assertArrayEquals(expectedPath.toArray(), dfs.getVisited().toArray());
}
@Test
public void testSearch4() {
Integer expectedValue = 4;
List<Integer> expectedPath = List.of(1, 2, 5, 6, 3, 4);
// check value
Optional<Node<Integer>> value = dfs.recursiveSearch(root, expectedValue);
assertEquals(expectedValue, value.orElse(new Node<>(null)).getValue());
// check path
assertArrayEquals(expectedPath.toArray(), dfs.getVisited().toArray());
}
@Test
void testNullRoot() {
var value = dfs.recursiveSearch(null, 4);
assertTrue(value.isEmpty());
}
@Test
void testSearchValueThatNotExists() {
List<Integer> expectedPath = List.of(1, 2, 5, 6, 3, 4);
var value = dfs.recursiveSearch(root, 10);
// check that the value is empty because it's not exists in the tree
assertTrue(value.isEmpty());
// check path is the whole list
assertArrayEquals(expectedPath.toArray(), dfs.getVisited().toArray());
}
}