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

48
com/xgiovio/ListPartitionTest.java Normal file
View File

@@ -0,0 +1,48 @@
package com.xgiovio;
import partition.ListPartition;
import position.NodePositionList;
import set.OrderedListSet;
import set.Set;
/**
* Created with MONSTER.
* User: xgiovio
* Date: 18/05/2014
* Time: 15:58
*/
public class ListPartitionTest {
public static void main(String[] args) {
ListPartition<String > a = new ListPartition<String>() ;
Set<String> a1 = a.makeSet("1");
System.out.println(a);
Set<String> a2 = a.makeSet("2");
System.out.println(a);
Set<String> a3 = a.makeSet("3");
System.out.println(a);
Set<String> a4 = a.makeSet("4");
System.out.println(a);
Set<String> out;
out = a.union(a1,a2);
System.out.println(a);
out = a.union(out,a3);
System.out.println(a);
out = a.union(out,a4);
System.out.println(a);
}
}

132
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() + ")";
}
}
}
*/

73
partition/ListPartition.java
View File

@@ -1,6 +1,14 @@
package partition;
import map.HashTableMap;
import position.NodePositionList;
import position.PositionList;
import set.OrderedListSet;
import set.Set;
import utility.DefaultComparator;
import java.security.InvalidKeyException;
import java.util.Iterator;
/**
* Created with xgiovio.macbookair.
@@ -10,30 +18,91 @@ import set.Set;
*/
public class ListPartition <E> implements Partition<E> {
private HashTableMap<E,Set<E>> elementi;
private PositionList<Set<E>> partizione;
public ListPartition () {
elementi = new HashTableMap<E, Set<E>>();
partizione = new NodePositionList<Set<E>>();
}
@Override
public int size() {
return 0;
return elementi.size();
}
@Override
public boolean isEmpty() {
return false;
return (size() == 0 );
}
@Override
public Set<E> makeSet(E x) {
try {
OrderedListSet<E> o = new OrderedListSet<E>(x, new DefaultComparator<E>());
elementi.put(x, o);
partizione.addLast(o);
o.setLocation(partizione.last());
return o;
}
catch (InvalidKeyException e){
}
return null;
}
@Override
public Set<E> union(Set<E> A, Set<E> B) {
try {
if (A.size() > B.size()){
OrderedListSet<E> AA = (OrderedListSet<E>) A;
OrderedListSet<E> BB = (OrderedListSet<E>) B;
AA.fastUnion(BB);
partizione.remove(BB.location());
BB.setLocation(null);
Iterator<E> it = BB.list().iterator();
for (;it.hasNext();)
elementi.put(it.next(),AA);
return AA;
} else {
OrderedListSet<E> AA = (OrderedListSet<E>) B;
OrderedListSet<E> BB = (OrderedListSet<E>) A;
AA.fastUnion(BB);
partizione.remove(BB.location());
BB.setLocation(null);
Iterator<E> it = BB.list().iterator();
for (;it.hasNext();)
elementi.put(it.next(),AA);
return AA;
}
}
catch (InvalidKeyException e){
}
return null;
}
@Override
public Set<E> find(E x) {
try {
return elementi.get(x);
}
catch (InvalidKeyException e){
}
return null;
}
@Override
public String toString() {
return partizione.toString();
}
}

28
set/OrderedListSet.java
View File

@@ -1,11 +1,13 @@
package set;
import position.NodePositionList;
import position.Position;
import position.PositionList;
import utility.DefaultComparator;
import utility.merge.MergeTemplate;
import java.util.Comparator;
import java.util.Iterator;
/**
* Created with xgiovio.macbookair.
@@ -17,6 +19,7 @@ import java.util.Comparator;
public class OrderedListSet <E> implements Set<E> {
private Comparator<E> c;
private PositionList<E> L;
private Position<Set<E>> loc;
@@ -99,8 +102,33 @@ public class OrderedListSet <E> implements Set<E> {
public Set<E> fastUnion(Set<E> B){
OrderedListSet<E> BB = (OrderedListSet<E>) B;
Iterator<E> it = BB.L.iterator();
for (;it.hasNext();)
L.addLast(it.next());
return this;
}
public E fastInsert(E x) {
L.addLast(x);
return x;
}
public Position<Set<E>> location (){
return loc;
}
public void setLocation (Position<Set<E>> in){
loc = in;
}
public PositionList<E> list (){
return L;
}
//////////////////////// inner class override methods from merge template /////