TAD Grafo

// Rafael Geronimo - Estrutura de Dados Não Lineares

package br.com.tadGrafo;

public class Main {
  public static void main(String[] args) {
    Grafo grafo = new Grafo();

    // Adicionar vértices
    Vertice v1 = grafo.inserirVertice("Luffy");
    Vertice v2 = grafo.inserirVertice("Ichigo");
    Vertice v3 = grafo.inserirVertice("Asta");
    Vertice v4 = grafo.inserirVertice("Mashle");

    // Adicionar arestas
    Aresta e1 = grafo.inserirAresta(v1, v2, "Edge 1", false);
    Aresta e2 = grafo.inserirAresta(v1, v3, "Edge 2", true);
    Aresta e3 = grafo.inserirAresta(v2, v4, "Edge 3", true);

    // Exibir o grafo formado
    System.out.println("Vértices:");
    for (Vertice v : grafo.vertices()) {
      System.out.println(v.getElement());
    }

    System.out.println("===========================");

    System.out.println("Arestas:");
    for (Aresta e : grafo.arestas()) {
      System.out.println(e.getElement() + " (Direcionado: " + grafo.isDirecionado(e) + ")");
    }
    System.out.println("===========================");

    // exibir Grafo
    grafo.imprimirGrafo();

    System.out.println("===========================");

    // Remoção de vértice
    Object elementoRemovido = grafo.removeVertice(v3);
    System.out.println("Elemento removido: " + elementoRemovido);

    // Remoção de aresta
    Object elementoRemovidoAresta = grafo.removeAresta(e3);
    System.out.println("Elemento removido da aresta: " + elementoRemovidoAresta);

    System.out.println("===========================");

    // Exibir o grafo formado
    System.out.println("Vértices:");
    for (Vertice v : grafo.vertices()) {
      System.out.println(v.getElement());
    }

    System.out.println("===========================");

    System.out.println("Arestas:");
    for (Aresta e : grafo.arestas()) {
      System.out.println(e.getElement() + " (Direcionado: " + grafo.isDirecionado(e) + ")");
    }

    // exibir Grafo
    grafo.imprimirGrafo();
  }

}

package br.com.tadGrafo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

public class Grafo {
  private Vector<Vertice> vertices;
  private Vector<Aresta> edges;

  public Grafo() {
    vertices = new Vector<Vertice>();
    edges = new Vector<Aresta>();
  }

  public Vector<Vertice> finalVertices(Aresta edge) {
    Vector<Vertice> vertexList = new Vector<Vertice>();
    vertexList.add(edge.getFromVertex());
    vertexList.add(edge.getToVertex());
    return vertexList;
  }

  public Vertice oposto(Vertice vertex, Aresta edge) {
    if (edge.getFromVertex() == vertex || edge.getToVertex() == vertex) {
      return edge.getFromVertex() == vertex ? edge.getToVertex() : edge.getFromVertex();
    }
    return vertex;
  }

  public boolean isAdjacente(Vertice vertex1, Vertice vertex2) {
    boolean isAdjacente = false;
    for (Aresta edge : vertex1.arestasIncidentes()) {
      if (edge.getFromVertex() == vertex2 || edge.getToVertex() == vertex2) {
        isAdjacente = true;
        break;
      }
    }
    return isAdjacente;
  }

  public void substituir(Vertice vertex, Object value) {
    vertex.setElement(value);
  }

  public void substituir(Aresta edge, Object value) {
    edge.setElement(value);
  }

  public Vertice inserirVertice(Object element) {
    Vertice vertex = new Vertice(element);
    vertices.add(vertex);
    return vertex;
  }

  public Aresta inserirAresta(Vertice fromVertex, Vertice toVertex, Object element, boolean isDirected) {
    Aresta edge = new Aresta(fromVertex, toVertex, element, isDirected);
    edges.add(edge);
    fromVertex.inserirAresta(edge);
    toVertex.inserirAresta(edge);
    return edge;
  }

  public Object removeVertice(Vertice vertex) {
    Object removedElement = vertex.getElement();
    while (vertex.arestasIncidentes().size() > 0) {
      removeAresta(vertex.arestasIncidentes().get(0));
    }
    vertices.remove(vertex);
    return removedElement;
  }

  public Object removeAresta(Aresta edge) {
    Object removedElement = edge.getElement();
    edge.getFromVertex().removeAresta(edge);
    edge.getToVertex().removeAresta(edge);
    edges.remove(edge);
    return removedElement;
  }

  public Iterator<Aresta> arestasIncidentes(Vertice vertex) {
    return vertex.arestasIncidentes().iterator();
  }

  public boolean isDirecionado(Aresta edge) {
    return edge.getIsDirected();
  }

  public List<Vertice> vertices() {
    return new ArrayList<>(vertices);
  }

  public List<Aresta> arestas() {
    return new ArrayList<>(edges);
  }

  public void imprimirGrafo() {
    // Percorre todos os vértices no grafo.
    for (Vertice v : vertices) {
      // Imprime o elemento do vértice atual e a string " está conectado com: ".
      System.out.print(v.getElement() + " está conectado com: ");
      // Percorre todas as arestas incidentes do vértice atual.
      for (Aresta a : v.arestasIncidentes()) {
        // Obtém o vértice oposto à aresta atual.
        Vertice oposto = oposto(v, a);
        // Imprime o elemento do vértice oposto, seguido de uma vírgula e um espaço.
        System.out.print(oposto.getElement() + ", ");
      }
      // Imprime uma quebra de linha para separar as descrições das conexões de
      // diferentes vértices.
      System.out.println();
    }
  }

}

package br.com.tadGrafo;

import java.util.Vector;

public class Vertice {
  private Object element;
  private Vector<Aresta> edges;

  Vertice(Object element) {
    this.element = element;
    this.edges = new Vector<Aresta>();
  }

  public Object getElement() {
    return this.element;
  }

  public void setElement(Object element) {
    this.element = element;
  }

  public void inserirAresta(Aresta edge) {
    edges.add(edge);
  };

  public void removeAresta(Aresta edge) {
    edges.remove(edge);
  };

  public Vector<Aresta> arestasIncidentes() {
    return edges;
  }
}

package br.com.tadGrafo;

public class Aresta {
  private Vertice fromVertex;
  private Vertice toVertex;
  private Object element;
  private boolean isDirected;

  Aresta(Vertice fromVertex, Vertice toVertex, Object element, boolean isDirected) {
    this.fromVertex = fromVertex;
    this.toVertex = toVertex;
    this.element = element;
    this.isDirected = isDirected;
  }

  public Vertice getFromVertex() {
    return this.fromVertex;
  }

  public Vertice getToVertex() {
    return this.toVertex;
  }

  public Object getElement() {
    return this.element;
  }

  public void setElement(Object element) {
    this.element = element;
  }

  public boolean getIsDirected() {
    return this.isDirected;
  }
}