رابط برنامه نویسی گراف وزندار (Edge Weighted Graph)

import java.util.Iterator;

public class Bag<Item> implements Iterable<Item> {

     private Node<Item> first;
     private int size;

     public Bag() {
          size = 0;
          first = null;
     }

     public boolean isEmpty() {
          return first == null;
     }

     public int size() {
          return size;
     }

     public void add(Item item) {
          Node<Item> oldfirst = first;
          first = new Node<Item>(item, oldfirst);
          size++;
     }

     public Iterator<Item> iterator() {
          return new ListIterator<Item>(first);
     }

}

public class Node<Item> {

     private Item data;
     private Node next_node;

     public Node(Item data, Node next_node) {
          this.data = data;
          this.next_node = next_node;
     }

     public Item getData() {
          return data;
     }

     public Node getNext_node() {
          return next_node;
     }
    
    

}

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ListIterator<Item> implements Iterator<Item> {
     private Node<Item> current;

     public ListIterator(Node<Item> first) {
          current = first;
     }

     public boolean hasNext() {
          return current != null;
     }


     public Item next() {
          if (!hasNext())
              throw new NoSuchElementException();
          Item item = current.getData();
          current = current.getNext_node();
          return item;
     }
}

public class Edge {

     private final int v;
     private final int w;
     private final double weight;


     public Edge(int v, int w, double weight) {
          if (v < 0)
              throw new IndexOutOfBoundsException(
                        "Vertex name must be a nonnegative integer");
          if (w < 0)
              throw new IndexOutOfBoundsException(
                        "Vertex name must be a nonnegative integer");
          if (Double.isNaN(weight))
              throw new IllegalArgumentException("Weight is NaN");
          this.v = v;
          this.w = w;
          this.weight = weight;
     }


     public double weight() {
          return weight;
     }


     public int either() {
          return v;
     }

     public int other(int vertex) {
          if (vertex == v)
              return w;
          else if (vertex == w)
              return v;
          else
              throw new IllegalArgumentException("Illegal endpoint");
     }


     public int compareTo(Edge that) {
          if (this.weight() < that.weight())
              return -1;
          else if (this.weight() > that.weight())
              return +1;
          else
              return 0;
     }


     public String toString() {
          return String.format("%d-%d %.5f", v, w, weight);
     }
}

public class EdgeWeightedGraph {
     private final int V;
     private int E;
     private Bag<Edge>[] adj;

     public EdgeWeightedGraph(int V) {
          if (V < 0)
              throw new IllegalArgumentException(
                        "Number of vertices must be nonnegative");
          this.V = V;
          this.E = 0;
          adj = (Bag<Edge>[]) new Bag[V];
          for (int v = 0; v < V; v++) {
              adj[v] = new Bag<Edge>();
          }
     }

     public int V() {
          return V;
     }

     public int E() {
          return E;
     }

     public void addEdge(Edge e) {
          int v = e.either();
          int w = e.other(v);
          if (v < 0 || v >= V)
              throw new IndexOutOfBoundsException("vertex " + v
                        + " is not between 0 and " + (V - 1));
          if (w < 0 || w >= V)
              throw new IndexOutOfBoundsException("vertex " + w
                        + " is not between 0 and " + (V - 1));
          adj[v].add(e);
          adj[w].add(e);
          E++;
     }

     public Iterable<Edge> adj(int v) {
          if (v < 0 || v >= V)
              throw new IndexOutOfBoundsException("vertex " + v
                        + " is not between 0 and " + (V - 1));
          return adj[v];
     }

     public Iterable<Edge> edges() {
          Bag<Edge> list = new Bag<Edge>();
          for (int v = 0; v < V; v++) {
              int selfLoops = 0;
              for (Edge e : adj(v)) {
                   if (e.other(v) > v) {
                        list.add(e);
                   } else if (e.other(v) == v) {
                        if (selfLoops % 2 == 0)
                             list.add(e);
                        selfLoops++;
                   }
              }
          }
          return list;
     }

     public String toString() {
          String NEWLINE = System.getProperty("line.separator");
          StringBuilder s = new StringBuilder();
          s.append(V + " " + E + NEWLINE);
          for (int v = 0; v < V; v++) {
              s.append(v + ": ");
              for (Edge e : adj[v]) {
                   s.append(e + "  ");
              }
              s.append(NEWLINE);
          }
          return s.toString();
     }

}

   public static void main(String[] args) {
          EdgeWeightedGraph G = new EdgeWeightedGraph(10);
          Edge e1 = new Edge(1, 2, 3);
          Edge e2 = new Edge(1, 3, 1);
          Edge e3 = new Edge(2, 5, 1);
          Edge e4 = new Edge(4, 3, 2);
          Edge e5 = new Edge(6, 5, 2);

          G.addEdge(e1);
          G.addEdge(e2);
          G.addEdge(e3);
          G.addEdge(e4);
          G.addEdge(e5);
         
          System.out.println("print Graph With ToString Method:");
          System.out.println(G.toString());
         
          System.out.println("print Graph with edges Method");
          for (Edge w : G.edges()) {
              System.out.println(w.toString());

          }
         
     }