xgiovio/unisa_strutture_dati_2013_2014
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Comepletata la ListPartion aggiungendo alcuni metodi a OrderedListset

Browse Source
This commit is contained in:
Giovanni Di Grezia
2014-05-20 18:49:37 +02:00
parent 4420be5086
commit 75199b5c96
4 changed files with 215 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
graph/AdjacencyListGraph.java
View File

@@ -15,25 +15,29 @@ import java.util.Iterator;
* @author Roberto Tamassia, Eric Zamore
*/
/*
public class AdjacencyListGraph<V,E> implements Graph<V,E> {
protected NodePositionList<Vertex<V>> VList; // container for vertices
protected NodePositionList<Edge<E>> EList; // container for edges
/** Default constructor that creates an empty graph */
// Default constructor that creates an empty graph
public AdjacencyListGraph() {
VList = new NodePositionList<Vertex<V>>();
EList = new NodePositionList<Edge<E>>();
}
/** Return an iterator over the vertices of the graph */
// Return an iterator over the vertices of the graph
public Iterable<Vertex<V>> vertices() {
return VList;
}
/** Return an iterator over the edges of the graph */
// Return an iterator over the edges of the graph
public Iterable<Edge<E>> edges() {
return EList;
}
/** Replace the element a given position (vertex or edge) with a new
element and return the old element */
// Replace the element a given position (vertex or edge) with a new element and return the old element
public Object replace(Position p, Object o)
throws InvalidPositionException {
MyPosition pp = checkPosition(p);
@@ -41,20 +45,23 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
pp.setElement(o);
return temp;
}
/** Return an iterator over the edges incident on a vertex */
// Return an iterator over the edges incident on a vertex
public Iterable<Edge<E>> incidentEdges(Vertex<V> v)
throws InvalidPositionException {
MyVertex<V> vv = checkVertex(v);
return vv.incidentEdges();
}
/** Return the endvertices of a edge in an array of length 2 */
// Return the endvertices of a edge in an array of length 2
public Vertex<V>[] endVertices(Edge<E> e)
throws InvalidPositionException {
MyEdge<E> ee = checkEdge(e);
return ee.endVertices();
}
/** Return the other endvertex of an incident edge */
// Return the other endvertex of an incident edge
public Vertex<V> opposite(Vertex<V> v, Edge<E> e)
throws InvalidPositionException {
checkVertex(v);
@@ -67,7 +74,8 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
else
throw new InvalidPositionException("No such vertex exists");
}
/** Test whether two vertices are adjacent */
// Test whether two vertices are adjacent
public boolean areAdjacent(Vertex<V> u, Vertex<V> v)
throws InvalidPositionException {
// search the incidence list of the vertex with smaller degree
@@ -86,7 +94,8 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
}
return false;
}
/** Insert and return a new vertex with a given element */
// Insert and return a new vertex with a given element
public Vertex<V> insertVertex(V o) {
MyVertex<V> vv = new MyVertex<V>(o);
VList.addLast(vv);
@@ -94,8 +103,8 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
vv.setLocation(p);
return vv;
}
/** Insert and return a new edge with a given element between two
vertices */
// Insert and return a new edge with a given element between two vertices
public Edge<E> insertEdge(Vertex<V> v, Vertex<V> w, E o)
throws InvalidPositionException {
MyVertex<V> vv = checkVertex(v);
@@ -109,8 +118,8 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
ee.setLocation(pe);
return ee;
}
/** Remove a vertex and all its incident edges and return the
element stored at the removed vertex */
// Remove a vertex and all its incident edges and return the element stored at the removed vertex
public V removeVertex(Vertex<V> v)
throws InvalidPositionException {
MyVertex<V> vv = checkVertex(v);
@@ -123,7 +132,8 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
VList.remove(vv.location());
return v.element();
}
/** Remove an edge and return its element */
// Remove an edge and return its element
public E removeEdge(Edge<E> e)
throws InvalidPositionException {
MyEdge<E> ee = checkEdge(e);
@@ -138,13 +148,13 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
// Auxiliary methods
/** Return the degree of a given vertex */
// Return the degree of a given vertex
public int degree(Vertex<V> v) {
MyVertex<V> vv = checkVertex(v);
return vv.degree();
}
/** Determines whether a given position is valid. */
// Determines whether a given position is valid.
protected MyPosition checkPosition(Position p)
throws InvalidPositionException {
if (p == null || !(p instanceof MyPosition))
@@ -152,7 +162,7 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
return (MyPosition) p;
}
/** Determines whether a given vertex is valid. */
// Determines whether a given vertex is valid.
protected MyVertex<V> checkVertex(Vertex<V> v)
throws InvalidPositionException {
if (v == null || !(v instanceof MyVertex))
@@ -160,7 +170,7 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
return (MyVertex<V>) v;
}
/** Determines whether a given edge is valid. */
// Determines whether a given edge is valid.
protected MyEdge<E> checkEdge(Edge<E> e)
throws InvalidPositionException {
if (e == null || !(e instanceof MyEdge))
@@ -168,24 +178,22 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
return (MyEdge<E>) e;
}
/** Implementation of a decorable position by means of a hash
* table. */
// Implementation of a decorable position by means of a hash table.
protected static class MyPosition<T>
extends HashTableMap<Object,Object> implements DecorablePosition<T> {
/** The element stored at this position. */
// The element stored at this position.
protected T elem;
/** Returns the element stored at this position. */
// Returns the element stored at this position.
public T element() {
return elem;
}
/** Sets the element stored at this position. */
// Sets the element stored at this position.
public void setElement(T o) {
elem = o;
}
}
/** Returns a string representation of the vertex and edge lists,
* separated by a newline. */
// Returns a string representation of the vertex and edge lists, separated by a newline.
public String toString() {
return VList.toString() + "\n" + EList.toString();
}
@@ -212,70 +220,65 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
return temp;
}
/** Implementation of a vertex for an undirected adjacency list
* graph. Each vertex stores its incidence container and position
* in the vertex container of the graph. */
//Implementation of a vertex for an undirected adjacency list
//graph. Each vertex stores its incidence container and position
//in the vertex container of the graph.
protected class MyVertex<V>
extends MyPosition<V> implements Vertex<V> {
/** Incidence container of the vertex. */
// Incidence container of the vertex.
protected PositionList<Edge<E>> incEdges;
/** Position of the vertex in the vertex container of the graph. */
// Position of the vertex in the vertex container of the graph.
protected Position<Vertex<V>> loc;
/** Constructs the vertex with the given element. */
// Constructs the vertex with the given element.
MyVertex(V o) {
elem = o;
incEdges = new NodePositionList<Edge<E>>();
}
/** Return the degree of a given vertex */
// Return the degree of a given vertex
public int degree() {
return incEdges.size();
}
/** Returns the incident edges on this vertex. */
// Returns the incident edges on this vertex.
public Iterable<Edge<E>> incidentEdges() {
return incEdges;
}
/** Inserts an edge into the incidence container of this vertex. */
// Inserts an edge into the incidence container of this vertex.
public Position<Edge<E>> insertIncidence(Edge<E> e) {
incEdges.addLast(e);
return incEdges.last();
}
/** Removes an edge from the incidence container of this vertex. */
//Removes an edge from the incidence container of this vertex.
public void removeIncidence(Position<Edge<E>> p) {
incEdges.remove(p);
}
/** Returns the position of this vertex in the vertex container of
* the graph. */
// Returns the position of this vertex in the vertex container of the graph.
public Position<Vertex<V>> location() {
return loc;
}
/** Sets the position of this vertex in the vertex container of
* the graph. */
// Sets the position of this vertex in the vertex container of the graph.
public void setLocation(Position<Vertex<V>> p) {
loc = p;
}
/** Returns a string representation of the element stored at this
* vertex. */
// Returns a string representation of the element stored at this vertex.
public String toString() {
return elem.toString();
}
}
/** Implementation of an edge for an undirected adjacency list
* graph. Each edge stores its endpoints (end vertices), its
* positions within the incidence containers of its endpoints, and
* position in the edge container of the graph. */
// Implementation of an edge for an undirected adjacency list
// graph. Each edge stores its endpoints (end vertices), its
// positions within the incidence containers of its endpoints, and
// position in the edge container of the graph.
protected class MyEdge<E> extends MyPosition<E> implements Edge<E> {
/** The end vertices of the edge. */
// The end vertices of the edge.
protected MyVertex<V>[] endVertices;
/** The positions of the entries for the edge in the incidence
* containers of the end vertices. */
// The positions of the entries for the edge in the incidence containers of the end vertices.
protected Position<Edge<E>>[] Inc;
/** The position of the edge in the edge container of the
* graph. */
// The position of the edge in the edge container of the graph.
protected Position<Edge<E>> loc;
/** Constructs an edge with the given endpoints and elements. */
// Constructs an edge with the given endpoints and elements.
MyEdge (Vertex<V> v, Vertex<V> w, E o) {
elem = o;
endVertices = (MyVertex<V>[]) new MyVertex[2];
@@ -283,38 +286,37 @@ public class AdjacencyListGraph<V,E> implements Graph<V,E> {
endVertices[1] = (MyVertex<V>)w;
Inc = (Position<Edge<E>>[]) new Position[2];
}
/** Returns the end vertices of the edge. There are always two
* elements in the returned array. */
// Returns the end vertices of the edge. There are always two elements in the returned array.
public MyVertex<V>[] endVertices() {
return endVertices;
}
/** Returns the positions of the edge in the incidence containers
* of its end vertices. The returned array always contains two
* elements. */
// Returns the positions of the edge in the incidence containers
// of its end vertices. The returned array always contains two
// elements.
public Position<Edge<E>>[] incidences() {
return Inc;
}
/** Sets the positions of the edge in the incidence containers of
* its end vertices. */
// Sets the positions of the edge in the incidence containers of its end vertices.
public void setIncidences(Position<Edge<E>> pv, Position<Edge<E>> pw) {
Inc[0] = pv;
Inc[1] = pw;
}
/** Returns the position of the edge in the edge container of the
* graph. */
// Returns the position of the edge in the edge container of the graph.
public Position<Edge<E>> location() {
return loc;
}
/** Sets the position of the edge in the edge container of the
* graph. */
// Sets the position of the edge in the edge container of the graph.
public void setLocation(Position<Edge<E>> p) {
loc = p;
}
/** Returns a string representation of the edge via a tuple of
* vertices. */
// Returns a string representation of the edge via a tuple of vertices.
public String toString() {
return element() + "(" + endVertices[0].toString() +
"," + endVertices[1].toString() + ")";
}
}
}
}
*/