diff --git a/Graph/README.md b/Graph/README.md new file mode 100644 index 0000000..e3f95ce --- /dev/null +++ b/Graph/README.md @@ -0,0 +1,75 @@ +Nesse projeto, está implementado um exemplo de grafo e uma busca em largura exemplificado no livro "Entendendo algoritmos". + +## Grafo + +Um grafo é uma estrutura matemática utilizada para modelar relações entre objetos. É composto por dois elementos principais: + +- **Vértices** (ou nós): Representam os objetos ou entidades. +- **Arestas** (ou ligações): Representam as conexões ou relações entre os vértices. + +### Tipos de Grafos +- **Grafo Não Direcionado**: As arestas não têm direção, ou seja, a relação entre os vértices é bidirecional. +- **Grafo Direcionado** (ou dígrafo): As arestas têm uma direção, indicando uma relação unidirecional entre os vértices. + + +### Aplicações de Grafos +Grafos são utilizados em diversas áreas, como: + +- **Redes de Computadores**: Para modelar a interconexão entre diferentes dispositivos. +- **Redes Sociais**: Para representar relações de amizade, seguidores, etc. +- **Roteamento**: Para encontrar o caminho mais curto ou mais eficiente entre dois pontos. +- **Bioinformática**: Para modelar relações entre genes e proteínas. + +## Busca em Largura (BFS) +A **Busca em Largura** (**BFS** - Breadth-First Search) é um algoritmo de travessia ou busca em grafos que explora os vértices de um grafo de maneira sistemática, nível por nível. A BFS é particularmente útil para encontrar o caminho mais curto em grafos não ponderados. + +### Como a BFS Funciona +- **Inicialização**: Comece pela raiz (ou nó inicial) e coloque-o em uma fila. +- **Exploração**: Remova o vértice da frente da fila, marque-o como visitado e coloque todos os seus vizinhos não visitados na fila. +- **Repetição**: Repita o processo de exploração até que a fila esteja vazia ou o nó de destino seja encontrado. + +_Exemplo_: + +Considere o seguinte grafo não direcionado: + +``` + A + / \ +B C +| | +D E +``` +Passos da BFS a partir do nó A: + +1. Inicialização: +- **Fila**: [A] +- **Visitados**: {A} + + +2. Exploração do nó A: +- **Fila**: [B, C] +- **Visitados**: {A, B, C} + +3. Exploração do nó B: +- **Fila**: [C, D] +- **Visitados**: {A, B, C, D} + +4. Exploração do nó C: +- **Fila**: [D, E] +- **Visitados**: {A, B, C, D, E} + +5. Exploração do nó D: +- **Fila**: [E] +- **Visitados**: {A, B, C, D, E} + +6. Exploração do nó E: +- Fila: [] +- Visitados: {A, B, C, D, E} + +Ao final do processo, todos os nós alcançáveis a partir de A foram visitados na ordem de suas distâncias da raiz. + +### Aplicações da BFS +- Encontrar o caminho mais curto em grafos não ponderados. +- Verificar conectividade entre dois vértices. +- Construção de árvores de cobertura mínima em grafos não direcionados. + diff --git a/Graph/pom.xml b/Graph/pom.xml new file mode 100644 index 0000000..0337acf --- /dev/null +++ b/Graph/pom.xml @@ -0,0 +1,17 @@ + + + 4.0.0 + + org.example + Graph + 1.0-SNAPSHOT + + + 19 + 19 + UTF-8 + + + \ No newline at end of file diff --git a/Graph/src/main/java/org/example/Graph.java b/Graph/src/main/java/org/example/Graph.java new file mode 100644 index 0000000..1877025 --- /dev/null +++ b/Graph/src/main/java/org/example/Graph.java @@ -0,0 +1,59 @@ +package org.example; + +import java.util.*; + +public class Graph { + private Map> adjList; + + public Graph() { + adjList = new HashMap<>(); + } + + public void addVertex(String vertex) { + adjList.putIfAbsent(vertex, new ArrayList<>()); + } + + public void addEdges(String vertex, List listOfVertex) { + adjList.putIfAbsent(vertex, new ArrayList<>()); + adjList.get(vertex).addAll(listOfVertex); + //adjList.get(vertex2).add(vertex1); //Para grafos não direcionados + } + public Map> getAdjList() { + return adjList; + } + + public void printGraph() { + for (String vertex : adjList.keySet()) { + System.out.print(vertex + " -> "); + for (String neighbor : adjList.get(vertex)) { + System.out.print(neighbor + " "); + } + System.out.println(); + } + } + + public void breathFirstSearch(String initialVertex) { + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + + visited.add(initialVertex); + queue.add(initialVertex); + + while(!queue.isEmpty()) { + String vertex = queue.poll(); + + if(isMangoSeller(vertex)) { + System.out.println("Found it: " + vertex); + return; + } else { + queue.addAll(adjList.get(vertex)); + } + } + + System.out.println("Didnt find it."); + } + + public boolean isMangoSeller(String vertex) { + return vertex.endsWith("m"); + } +} diff --git a/Graph/src/main/java/org/example/Main.java b/Graph/src/main/java/org/example/Main.java new file mode 100644 index 0000000..fcb2af0 --- /dev/null +++ b/Graph/src/main/java/org/example/Main.java @@ -0,0 +1,24 @@ +package org.example; + +import java.util.List; + +public class Main { + public static void main(String[] args) { + + System.out.println("Hello world!"); + + Graph graph = new Graph(); + graph.addEdges("voce", List.of("alice", "bob", "claire")); + graph.addEdges("bob", List.of("anuj", "peggy")); + graph.addEdges("claire", List.of("thom", "jonny")); + graph.addEdges("alice", List.of("peggy")); + graph.addVertex("anuj"); + graph.addVertex("peggy"); + graph.addVertex("thom"); + graph.addVertex("jonny"); + + graph.printGraph(); + + graph.breathFirstSearch("voce"); + } +} \ No newline at end of file diff --git a/Graph/target/classes/org/example/Graph.class b/Graph/target/classes/org/example/Graph.class new file mode 100644 index 0000000..8f5670a Binary files /dev/null and b/Graph/target/classes/org/example/Graph.class differ diff --git a/Graph/target/classes/org/example/Main.class b/Graph/target/classes/org/example/Main.class new file mode 100644 index 0000000..960ead5 Binary files /dev/null and b/Graph/target/classes/org/example/Main.class differ