Newsgroup: it.comp.java
Titolo: [source] class Graph

package crivellaro.datatypes;
import java.util.Vector;
import java.util.Iterator;
import java.util.Collections;
/**
 * Questa classe definisce un grafo, cioč un insieme di nodi
 * e di archi che li collegano. L'insieme dei nodi č memorizzato in
 * un <code>Vector</code> mentre gli archi sono memorizzati in un
 * <code>Vector</code> ordinato secondo la loro lunghezza,
 * cosa che facilita l'implementazione degli algoritmi che
 * lavorano sui grafi.
 *
 * @see Node
 * @see Arc
 */
public class Graph {
    private Vector nodeSet;
    private Vector arcQueue;
 /**
  * Costruisce un grafo con i nodi e gli archi passati come parametri.
  *
  * @param   nodeSet  L'insieme dei nodi.
  * @param   arcQueue  L'insieme degli archi.
  */
    public Graph(Vector nodeSet , Vector arcQueue) {
     this.nodeSet   = nodeSet;
        Collections.sort(arcQueue);
     this.arcQueue  = arcQueue;
    }
 /**
  * Restituisce il numero di nodi del grafo.
  *
  * @return     Il numero di nodi del grafo.
  */
    public int numNodes() {
        return this.nodeSet.size();
    }
 /**
  * Restituisce il numero di archi del grafo.
  *
  * @return     Il numero di archi del grafo.
  */
    public int numArcs() {
        return this.arcQueue.size();
    }
 /**
  * Restituisce i nodi del grafo.
  *
  * @return     I nodi del grafo.
  */
    public Vector getNodes() {
        return this.nodeSet;
    }
 /**
  * Restituisce gli archi del grafo.
  *
  * @return     gli archi del grafo.
  */
    public Vector getArcs() {
        return this.arcQueue;
    }
 /**
  * Restituisce i nodi adiacenti al nodo passato come parametro.
  *
  * @param   node  Il nodo di cui si vogliono gli adiacenti.
  * @return     Il Vector dei nodi adiacenti.
  * @exception   NodeNotInGraphException Viene lanciata se il
     * nodo passato come parametro non appartiene al grafo.
  */
    public Vector adjacentNodes(Node node)
    throws NodeNotInGraphException {
        Vector adjacentNodes = new Vector();
        if (this.contains(node)) {
            for (Iterator it = arcQueue.iterator(); it.hasNext();) {
             Arc arc= (Arc)it.next();
                if (arc.getOriginNode() == node) {
                 boolean alreadyInserted = false;
                    for (Iterator it2 = adjacentNodes.iterator();
it2.hasNext();) {
                  if (it2.next() == arc.getDestinationNode()) {
                   alreadyInserted = true;
                            break;
                        }
                    }
                    if (!alreadyInserted)
                  adjacentNodes.addElement(arc.getDestinationNode());
                }
                else if (arc.getDestinationNode() == node) {
                 boolean alreadyInserted = false;
                    for (Iterator it2 = adjacentNodes.iterator();
it2.hasNext();) {
                  if (it2.next() == arc.getOriginNode()) {
                   alreadyInserted = true;
                            break;
                        }
                    }
                    if (!alreadyInserted)
                  adjacentNodes.addElement(arc.getOriginNode());
                }
            }
        }
        else {
         throw new NodeNotInGraphException();
        }
        return adjacentNodes;
    }
 /**
  * Restituisce gli archi incidenti il nodo passato come parametro.
  *
  * @param   node  Il nodo di cui si vogliono gli archi incidenti.
  * @return     Il Vector degli archi incidenti.
  * @exception   NodeNotInGraphException  Viene lanciata se il nodo
     * passato come parametro non appartiene al grafo.
  */
    public Vector incidentArcs(Node node)
    throws NodeNotInGraphException {
     Vector incidentArcs = new Vector();
        if (this.contains(node)) {
            for (Iterator it = arcQueue.iterator(); it.hasNext();) {
             Arc arc= (Arc)it.next();
                if ((arc.getOriginNode() == node)||(arc.getDestinationNode()
== node))
                 incidentArcs.addElement(arc);
            }
        }
        else {
         throw new NodeNotInGraphException();
        }
        return incidentArcs;
    }
 /**
  * Restituisce l'arco di minima lunghezza, se esiste, che collega
     * i nodi passati come parametri.
  *
  * @param   node  Il primo nodo.
     * @param   node  Il secondo nodo.
  * @return     Un arco che collega i due nodi, se esiste;
     * <code>null</code> altrimenti.
  * @exception   NodeNotInGraphException  Viene lanciata se i nodi
     * passati come parametri non appartengono al grafo.
  */
    public Arc incidentArc(Node node1, Node node2)
    throws NodeNotInGraphException {
     Arc incidentArc = null;
        if (this.contains(node1)&&this.contains(node2)) {
   if (this.areAdjacent(node1,node2)) {
    Vector incidentArcs = this.incidentArcs(node1);
                Collections.sort(incidentArcs);
                for (Iterator it = incidentArcs.iterator(); it.hasNext();) {
                 Arc arc = (Arc)it.next();
                    if ((arc.getOriginNode()      == node2) ||
                        (arc.getDestinationNode() == node2))
                        return arc;
                }
            }
            else {
             return null;
            }
        }
        else {
         throw new NodeNotInGraphException();
        }
        return incidentArc;
    }
 /**
  * Controlla se i nodi passati come parametri sono adiacenti.
  *
  * @param   node1  Il primo nodo.
  * @param   node2  Il secondo nodo.
  * @return     <code>true</code> se i nodi sono adiacenti,
     * <code>false</code> altrimenti.
  * @exception   NodeNotInGraphException  Viene lanciata se uno
     * dei due nodi passati come parametri non appartiene al grafo.
  */
    public boolean areAdjacent(Node node1, Node node2)
    throws NodeNotInGraphException {
     boolean areAdjacent = false;
     if (this.contains(node1)&&this.contains(node2)) {
         Vector adjNodes = this.adjacentNodes(node1);
            for (Iterator it = adjNodes.iterator(); it.hasNext();) {
       if ((Node)it.next() == node2) {
           areAdjacent = true;
                    break;
                }
            }
     }
        else {
         throw new NodeNotInGraphException();
        }
        return areAdjacent;
    }
 /**
  * Verifica se il nodo passato come parametro appartiene
  * al grafo.
  *
  * @param   node Il nodo in esame.
  * @return  <code>true</code> se il nodo appartiene al grafo,
  * <code>false</code> altrimenti.
  */
    public boolean contains(Node node) {
        boolean contains = false;
        for (Iterator it = nodeSet.iterator(); it.hasNext();) {
         if (it.next() == node) {
          contains = true;
                break;
            }
        }
        return contains;
    }
}

Grazie 1000 :)