mirror of
https://github.com/TheAlgorithms/Java.git
synced 2025-07-07 17:56:02 +08:00
2
pom.xml
2
pom.xml
@ -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
32
src/main/java/com/thealgorithms/datastructures/Node.java
Normal 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;
|
||||
}
|
||||
}
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
@ -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());
|
||||
}
|
||||
}
|
@ -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());
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user