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

Rimosso ArraySequenceFake. Implementato positions() in NodePositionList. Creato il DefaultComparator. Prima implementazione di SortedPriorityList

Browse Source
This commit is contained in:
Giovanni Di Grezia
2014-04-01 22:06:51 +02:00
parent 9836790893
commit 5e892f4961
10 changed files with 230 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
com/xgiovio/ArraySequenceFakeTest.java
View File

@@ -1,25 +0,0 @@
package com.xgiovio;
import general_utility.test_object;
import position.Position;
import sequence.ArraySequenceFake;
/**
* Created with xgiovio.macbookair.
* User: xgiovio
* Date: 23/03/14
* Time: 20:37
*/
public class ArraySequenceFakeTest {
public static void main(String[] args) {
ArraySequenceFake<test_object> a = new ArraySequenceFake<test_object>(10);
a.addFirst(new test_object(3));
Position<test_object> p = a.addAfter(a.first(), new test_object(6));
System.out.print(a);
}
}

13
com/xgiovio/NodePositionListTest.java
View File

@@ -3,6 +3,7 @@ package com.xgiovio;
import arraylist.ArrayIndexList;
import general_utility.test_object;
import position.NodePositionList;
import position.Position;
import java.util.Iterator;
@@ -38,6 +39,18 @@ public class NodePositionListTest {
System.out.print(it.next());
System.out.print(it.hasNext());
Iterator<Position<test_object>> itp = a.positions();
System.out.print(itp.hasNext());
System.out.print(itp.next().element());
System.out.print(itp.hasNext());
System.out.print(itp.next().element());
System.out.print(itp.hasNext());
System.out.print(itp.next().element());
System.out.print(itp.hasNext());
System.out.print(itp.next().element());
System.out.print(itp.hasNext());

70
position/NodePositionList.java
View File

@@ -251,7 +251,7 @@ public class NodePositionList<E> implements PositionList<E> {
@Override
public void remove() {
throw new UnsupportedOperationException ();
}
NodePositionList<E> new_structure;
@@ -260,5 +260,73 @@ public class NodePositionList<E> implements PositionList<E> {
}
@Override
public Iterator<Position<E>> positions() {
return new MyPositionsIterator(this);
}
class MyPositionsIterator implements Iterator<Position<E>>{
public MyPositionsIterator (NodePositionList<E> structure){
new_structure = new NodePositionList<Position<E>>();
if (structure.size() != 0){
Position<E> temp;
for (temp = structure.first() ; temp!= structure.last() ; temp = structure.next(temp)){
new_structure.addLast(temp);
}
new_structure.addLast(temp);
}
}
@Override
public boolean hasNext() {
if (pos == null){
if (new_structure.size() <= 0){
return false;
} else {
return true;
}
} else {
try {
new_structure.next(pos);
return true;
}
catch (BoundaryViolationException err){
return false;
}
}
}
@Override
public Position<E> next() throws NoSuchElementException {
if (hasNext()){
if (pos == null){
pos = new_structure.first();
}else {
pos = new_structure.next(pos);
}
return pos.element();
} else{
throw new NoSuchElementException();
}
}
@Override
public void remove() {
throw new UnsupportedOperationException ();
}
NodePositionList<Position<E>> new_structure;
Position<Position<E>> pos = null;
}
}

3
position/PositionList.java
View File

@@ -37,5 +37,8 @@ public interface PositionList<E> extends Iterable<E> {
public E set(Position<E> p, E e) throws InvalidPositionException;
public Iterator<Position<E>> positions();
}

37
priorityqueue/MyEntry.java Normal file
View File

@@ -0,0 +1,37 @@
package priorityqueue;
/**
* Created with MONSTER.
* User: xgiovio
* Date: 01/04/2014
* Time: 21:00
*/
public class MyEntry<K,V> implements Entry<K,V> {
public MyEntry(K a, V b){
key = a;
value = b;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public String toString() {
return ("" + key + " - " + value);
}
private K key;
private V value;
}

88
priorityqueue/SortedListPriorityQueue.java Normal file
View File

@@ -0,0 +1,88 @@
package priorityqueue;
import exceptions.EmptyPriorityQueueException;
import position.NodePositionList;
import position.Position;
import utility.DefaultComparator;
import java.security.InvalidKeyException;
import java.util.Comparator;
import java.util.Iterator;
/**
* Created with MONSTER.
* User: xgiovio
* Date: 01/04/2014
* Time: 20:57
*/
public class SortedListPriorityQueue<K,V> implements PriorityQueue<K,V> {
private NodePositionList<MyEntry<K,V>> data = new NodePositionList<MyEntry<K, V>>();
private Comparator<K> c;
public SortedListPriorityQueue(){
c = new DefaultComparator<K>();
}
public SortedListPriorityQueue(Comparator<K> comp){
c = comp;
}
@Override
public int size() {
return data.size();
}
@Override
public boolean isEmpty() {
return data.isEmpty();
}
@Override
public Entry<K, V> min() throws EmptyPriorityQueueException {
if (isEmpty()){
throw new EmptyPriorityQueueException();
} else {
return data.first().element();
}
}
@Override
public Entry<K, V> insert(K key, V value) throws InvalidKeyException {
try {
MyEntry<K, V> t = new MyEntry<K, V>(key, value);
if (data.size() == 0) {
data.addFirst(t);
return t;
} else {
Iterator<Position<MyEntry<K, V>>> itp = data.positions();
int status;
Position<MyEntry<K, V>> temp_pos = null;
for (; itp.hasNext(); ) {
temp_pos = itp.next();
status = c.compare(temp_pos.element().getKey(), key);
if (status > 0)
data.addBefore(temp_pos, t);
return t;
}
data.addLast(t);
return t;
}
}
catch (ClassCastException err){
throw new InvalidKeyException();
}
}
@Override
public Entry<K, V> removeMin() throws EmptyPriorityQueueException {
if (isEmpty()){
throw new EmptyPriorityQueueException();
} else {
return data.remove(data.first());
}
}
}

5
sequence/ArraySequence.java
View File

@@ -290,4 +290,9 @@ public class ArraySequence<E> implements Sequence<E> {
public Iterator<E> iterator() {
return null;
}
@Override
public Iterator<Position<E>> positions() {
return null;
}
}

228
sequence/ArraySequenceFake.java
View File

@@ -1,228 +0,0 @@
package sequence;
import arraylist.ArrayIndexList;
import exceptions.BoundaryViolationException;
import exceptions.EmptyListException;
import exceptions.EmptySequenceException;
import exceptions.InvalidPositionException;
import position.Position;
import sequence.utility.DNodeFake;
import java.util.Iterator;
/**
* Created with MONSTER.
* User: xgiovio
* Date: 30/03/2014
* Time: 17:19
*/
// fake positions created on the fly. if the element in the array change, it doesn't change on the position retrieved before.
public class ArraySequenceFake<E> extends ArrayIndexList<E> implements Sequence<E> {
public ArraySequenceFake(int in){
super(in);
}
@Override
public E getFirst() throws EmptySequenceException {
try {
E ele = get(0);
return ele;
}
catch (IndexOutOfBoundsException err){
throw new EmptySequenceException();
}
}
@Override
public E getLast() throws EmptySequenceException {
try {
E ele = get(size()-1);
return ele;
}
catch (IndexOutOfBoundsException err){
throw new EmptySequenceException();
}
}
@Override
public E removeFirst() throws EmptySequenceException {
try {
E ele = remove(0);
return ele;
}
catch (IndexOutOfBoundsException err){
throw new EmptySequenceException();
}
}
@Override
public E removeLast() throws EmptySequenceException {
try {
E ele = remove(size() - 1);
return ele;
}
catch (IndexOutOfBoundsException err){
throw new EmptySequenceException();
}
}
@Override
public Position<E> atIndex(int in_index) throws BoundaryViolationException {
try {
checkIndex(in_index, size());
return new DNodeFake<E>(get(in_index),in_index);
}
catch (IndexOutOfBoundsException err){
throw new BoundaryViolationException();
}
}
@Override
public int indexOf(Position<E> position) throws InvalidPositionException {
checkPosition(position);
return ((DNodeFake<E>) position).getIndex();
}
@Override
public Position<E> first() throws EmptyListException {
try{
return new DNodeFake<E>(get(0),0);
}
catch (IndexOutOfBoundsException err){
throw new EmptyListException("Empty Array");
}
}
@Override
public Position<E> last() throws EmptyListException {
try{
return new DNodeFake<E>(get(size() - 1),size() - 1);
}
catch (IndexOutOfBoundsException err){
throw new EmptyListException("Empty Array");
}
}
@Override
public Position<E> next(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
DNodeFake<E> t = checkPosition(p);
if (t.getIndex()< size() -1){
return new DNodeFake<E>(get(t.getIndex() + 1),t.getIndex() + 1);
}else{
throw new BoundaryViolationException();
}
}
@Override
public Position<E> prev(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
DNodeFake<E> t = checkPosition(p);
if (t.getIndex()> 0){
return new DNodeFake<E>(get(t.getIndex() - 1),t.getIndex() - 1);
}else{
throw new BoundaryViolationException();
}
}
@Override
public void addFirst(E e) {
add (0,e);
}
@Override
public void addLast(E e) {
add (size(),e);
}
@Override
public Position<E> addAfter(Position<E> p, E e) throws InvalidPositionException {
try {
DNodeFake<E> t = checkPosition(p);
add(t.getIndex() + 1, e);
return new DNodeFake<E>(get(t.getIndex() + 1),t.getIndex() + 1);
}
catch (IndexOutOfBoundsException err){
throw new InvalidPositionException();
}
}
@Override
public Position<E> addBefore(Position<E> p, E e) throws InvalidPositionException {
try {
DNodeFake<E> t = checkPosition(p);
add(t.getIndex() - 1,e);
return new DNodeFake<E>(get(t.getIndex() - 1),t.getIndex() - 1);
}
catch (IndexOutOfBoundsException err){
throw new InvalidPositionException();
}
}
@Override
public E remove(Position<E> p) throws InvalidPositionException {
try {
DNodeFake<E> t = checkPosition(p);
return remove(t.getIndex());
}
catch (IndexOutOfBoundsException err){
throw new InvalidPositionException();
}
}
@Override
public E set(Position<E> p, E e) throws InvalidPositionException {
try {
DNodeFake<E> t = checkPosition(p);
return set (t.getIndex(),e);
}
catch (IndexOutOfBoundsException err){
throw new InvalidPositionException();
}
}
@Override
public String toString() {
String to_return = "";
to_return = to_return + "[";
for ( int i = 0; i< size() ; i++){
if ( i== size() -1){
to_return+=(get(i).toString());
}else{
to_return+=(get(i).toString() + ",");
}
}
to_return = to_return + "]";
return to_return;
}
protected DNodeFake<E> checkPosition(Position<E> p) throws InvalidPositionException {
if (p == null)
throw new InvalidPositionException
("Null position passed");
try {
DNodeFake<E> temp = (DNodeFake<E>) p;
if ( temp.getIndex() >= size() || temp.getIndex() < 0 )
throw new InvalidPositionException
("Position does not belong to a valid value");
return temp;
} catch (ClassCastException e) {
throw new InvalidPositionException
("Position is of wrong type for this array");
}
}
@Override
public Iterator<E> iterator() {
return null;
}
}

51
sequence/utility/DNodeFake.java
View File

@@ -1,51 +0,0 @@
package sequence.utility;
import exceptions.InvalidPositionException;
import position.Position;
/**
* A simple node class for a doubly-linked list. Each DNode has a
* reference to a stored element, a previous node, and a next node.
*
* @author Roberto Tamassia
*/
//Copyright (c) 2003 Brown University, Providence, RI
//Additional modifications and methods by xgiovio
// used on ArraySequenceFake
public class DNodeFake<E> implements Position<E> {
private E element = null;
private int index = -1;
public DNodeFake(E elem, int in_idex) {
element = elem;
index = in_idex;
}
public DNodeFake(E elem) {
element = elem;
}
public E element() throws InvalidPositionException {
if (index == -1)
throw new InvalidPositionException("Position is not in a list!");
return element;
}
public void setElement(E newElement) { element = newElement; }
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}

15
utility/DefaultComparator.java Normal file
View File

@@ -0,0 +1,15 @@
package utility;
import java.util.Comparator;
/**
* Created with MONSTER.
* User: xgiovio
* Date: 01/04/2014
* Time: 20:56
*/
public class DefaultComparator<E> implements Comparator<E> {
public int compare(E a, E b)throws ClassCastException {
return ((Comparable<E>)a).compareTo(b);
}
}