From e53f98a3a87742318f2f3caa0d66294b599c5080 Mon Sep 17 00:00:00 2001 From: Giovanni Di Grezia Date: Sun, 1 Jun 2014 18:16:43 +0200 Subject: [PATCH] Fixato bug e implementato alcune funzioni. --- com/xgiovio/HeapPrioriyQueueTest.java | 42 ++++ com/xgiovio/Main.java | 14 ++ dictionary/BinarySearchTree.java | 3 +- dictionary/ChainingHashTable.java | 2 +- dictionary/Dictionary.java | 2 +- dictionary/LinearProbingHashTable.java | 2 +- dictionary/Logfile.java | 2 +- exceptions/InvalidKeyException.java | 11 + graph/BFS.java | 2 +- graph/ComponentsBFS.java | 14 +- graph/ComponentsDFS.java | 2 +- graph/DFS.java | 2 +- iterator/ElementIterator.java | 76 ++----- map/HashTableMap.java | 2 +- map/ListMap.java | 2 +- map/Map.java | 2 +- partition/ListPartition.java | 25 +-- priorityqueue/AdaptablePriorityQueue.java | 2 +- priorityqueue/PriorityQueue.java | 2 +- .../SortedListAdaptablePriorityQueue.java | 2 +- priorityqueue/SortedListPriorityQueue.java | 2 +- priorityqueue/UnsortedListPriorityQueue.java | 2 +- .../heap/HeapAdaptablePriorityQueue.java | 2 +- priorityqueue/heap/HeapPriorityQueue.java | 18 +- .../ExBinaryTree_11_2_13.java | 210 ++++++++++++++++++ .../ExGraph_15_6PerEserc.java | 164 ++++++++++++++ test_2_prova_intercorso/ExMap15_1.java | 117 ++++++++++ test_2_prova_intercorso/ExPQ_21_2_11.java | 65 +++--- test_2_prova_intercorso/ExTree_17_1_2013.java | 186 ++++++++++++++++ test_2_prova_intercorso/General.java | 82 +++++++ .../heap/ArrayListCompleteBinaryTree.java | 2 +- 31 files changed, 910 insertions(+), 151 deletions(-) create mode 100644 com/xgiovio/HeapPrioriyQueueTest.java create mode 100644 exceptions/InvalidKeyException.java create mode 100644 test_2_prova_intercorso/ExBinaryTree_11_2_13.java create mode 100644 test_2_prova_intercorso/ExGraph_15_6PerEserc.java create mode 100644 test_2_prova_intercorso/ExMap15_1.java create mode 100644 test_2_prova_intercorso/ExTree_17_1_2013.java create mode 100644 test_2_prova_intercorso/General.java diff --git a/com/xgiovio/HeapPrioriyQueueTest.java b/com/xgiovio/HeapPrioriyQueueTest.java new file mode 100644 index 0000000..6dd54b9 --- /dev/null +++ b/com/xgiovio/HeapPrioriyQueueTest.java @@ -0,0 +1,42 @@ +package com.xgiovio; + +import com.xgiovio.general_utility.test_object; +import priorityqueue.heap.HeapPriorityQueue; +import stack.NodeStack; +import utility.DefaultComparator; + +/** + * Created with xgiovio.macbookair. + * User: xgiovio + * Date: 23/03/14 + * Time: 20:37 + */ +public class HeapPrioriyQueueTest { + + public static void main(String[] args) { + + Integer[] b = new Integer[5] ; + b[0] = new Integer(7); + b[1] = new Integer(5); + b[2] = new Integer(-8); + b[3] = new Integer(8); + b[4] = new Integer(-2); + + String[] c = new String[5] ; + c[0] = new String("ale"); + c[1] = new String("ale"); + c[2] = new String("ale"); + c[3] = new String("ale"); + c[4] = new String("ale"); + + + + HeapPriorityQueue a = new HeapPriorityQueue (b,c, new DefaultComparator()); + + System.out.println(a.min().getKey()); + System.out.println(a); + + + } + +} diff --git a/com/xgiovio/Main.java b/com/xgiovio/Main.java index b5c48d5..6d2d0a0 100644 --- a/com/xgiovio/Main.java +++ b/com/xgiovio/Main.java @@ -1,8 +1,22 @@ package com.xgiovio; +import position.NodePositionList; + +import java.util.Iterator; + public class Main { public static void main(String[] args) { + NodePositionList a = new NodePositionList(); + a.addLast(1); + a.addLast(2); + Iterator it = a.iterator(); + a.addLast(3); + a.addLast(4); + + for (;it.hasNext();) + System.out.println(it.next()); + } } diff --git a/dictionary/BinarySearchTree.java b/dictionary/BinarySearchTree.java index 727e15c..fd882dd 100644 --- a/dictionary/BinarySearchTree.java +++ b/dictionary/BinarySearchTree.java @@ -1,5 +1,6 @@ package dictionary; import exceptions.InvalidEntryException; +import exceptions.InvalidKeyException; import position.NodePositionList; import position.Position; import position.PositionList; @@ -8,7 +9,7 @@ import tree.binarytree.BTPosition; import tree.binarytree.LinkedBinaryTree; import utility.DefaultComparator; -import java.security.InvalidKeyException; + import java.util.Comparator; diff --git a/dictionary/ChainingHashTable.java b/dictionary/ChainingHashTable.java index 81c48f3..2fdf6b3 100644 --- a/dictionary/ChainingHashTable.java +++ b/dictionary/ChainingHashTable.java @@ -7,7 +7,7 @@ import exceptions.InvalidEntryException; import position.NodePositionList; import priorityqueue.Entry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Iterator; /** diff --git a/dictionary/Dictionary.java b/dictionary/Dictionary.java index bcfd78e..0c8b90f 100644 --- a/dictionary/Dictionary.java +++ b/dictionary/Dictionary.java @@ -3,7 +3,7 @@ package dictionary; import exceptions.InvalidEntryException; import priorityqueue.Entry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; public interface Dictionary { diff --git a/dictionary/LinearProbingHashTable.java b/dictionary/LinearProbingHashTable.java index 6665921..749913d 100644 --- a/dictionary/LinearProbingHashTable.java +++ b/dictionary/LinearProbingHashTable.java @@ -8,7 +8,7 @@ import position.NodePositionList; import priorityqueue.Entry; import priorityqueue.MyEntry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Iterator; /** diff --git a/dictionary/Logfile.java b/dictionary/Logfile.java index 9335705..31ee588 100644 --- a/dictionary/Logfile.java +++ b/dictionary/Logfile.java @@ -6,7 +6,7 @@ import position.Position; import priorityqueue.Entry; import priorityqueue.MyEntry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; /** * Created with MONSTER. diff --git a/exceptions/InvalidKeyException.java b/exceptions/InvalidKeyException.java new file mode 100644 index 0000000..573f6ee --- /dev/null +++ b/exceptions/InvalidKeyException.java @@ -0,0 +1,11 @@ +package exceptions; + + +public class InvalidKeyException extends RuntimeException { + public InvalidKeyException(String message) { + super (message); + } + public InvalidKeyException() { + super ("Invalid Key Exception"); + } +} diff --git a/graph/BFS.java b/graph/BFS.java index fe013b1..ea73007 100644 --- a/graph/BFS.java +++ b/graph/BFS.java @@ -9,7 +9,7 @@ import arraylist.IndexList; import position.NodePositionList; import position.PositionList; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; public abstract class BFS { protected Graph graph; diff --git a/graph/ComponentsBFS.java b/graph/ComponentsBFS.java index 864d35a..983e1c1 100644 --- a/graph/ComponentsBFS.java +++ b/graph/ComponentsBFS.java @@ -2,7 +2,7 @@ package graph; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; public class ComponentsBFS extends BFS { protected Integer compNumber; @@ -13,16 +13,11 @@ public class ComponentsBFS extends BFS { } protected void startVisit(Vertex v) { - try { v.put(COMPONENT, compNumber); - } - catch (InvalidKeyException e){ - - } } protected Integer finalResult(Integer bfsResult) { - try { + for(Vertex v : graph.vertices()) if(!isVisited(v)) { compNumber++; @@ -30,10 +25,5 @@ public class ComponentsBFS extends BFS { } return compNumber; - } - catch (InvalidKeyException e){ - - } - return null; } } diff --git a/graph/ComponentsDFS.java b/graph/ComponentsDFS.java index ac40c97..874a83b 100644 --- a/graph/ComponentsDFS.java +++ b/graph/ComponentsDFS.java @@ -2,7 +2,7 @@ package graph; //begin#fragment CC -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; /** This class extends DFS to compute the connected components of a graph. */ public class ComponentsDFS extends DFS { diff --git a/graph/DFS.java b/graph/DFS.java index bc6e7a4..5457617 100644 --- a/graph/DFS.java +++ b/graph/DFS.java @@ -1,7 +1,7 @@ package graph; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; /** Generic DFS traversal of a graph using the template method pattern. * Parameterized types: diff --git a/iterator/ElementIterator.java b/iterator/ElementIterator.java index bafcf06..0496e8d 100644 --- a/iterator/ElementIterator.java +++ b/iterator/ElementIterator.java @@ -1,74 +1,34 @@ package iterator; -import exceptions.BoundaryViolationException; import position.Position; import position.PositionList; import java.util.Iterator; import java.util.NoSuchElementException; -/** - * Created with MONSTER. - * User: xgiovio - * Date: 06/04/2014 - * Time: 21:06 - */ - -//iterator implementation with cursor for PositionList data structures. public class ElementIterator implements Iterator { + protected PositionList list; // the underlying list + protected Position cursor; // the next position - public ElementIterator (PositionList structure){ + public ElementIterator(PositionList L) { + list = L; + cursor = (list.isEmpty())? null : list.first(); + } - new_structure = structure; + public boolean hasNext() { return (cursor != null); } - } + public E next() throws NoSuchElementException { + if (cursor == null) + throw new NoSuchElementException("No next element"); + E toReturn = cursor.element(); + cursor = (cursor == list.last())? null : list.next(cursor); + return toReturn; + } - @Override - public boolean hasNext() { - if (pos == null){ - if (new_structure. size() <= 0){ - return false; - } else { - return true; - } + public void remove() throws UnsupportedOperationException { + throw new UnsupportedOperationException("remove"); + } - } else { +} - try { - new_structure.next(pos); - return true; - } - catch (BoundaryViolationException err){ - return false; - - } - - - } - } - - @Override - public 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 (); - } - - PositionList new_structure = null; - Position pos = null; - - -} \ No newline at end of file diff --git a/map/HashTableMap.java b/map/HashTableMap.java index 057a992..00d17c3 100644 --- a/map/HashTableMap.java +++ b/map/HashTableMap.java @@ -5,7 +5,7 @@ import position.NodePositionList; import position.PositionList; import priorityqueue.Entry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Iterator; /** diff --git a/map/ListMap.java b/map/ListMap.java index 3adf21d..9c0318b 100644 --- a/map/ListMap.java +++ b/map/ListMap.java @@ -6,7 +6,7 @@ import position.PositionList; import priorityqueue.Entry; import priorityqueue.MyEntry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Iterator; /** diff --git a/map/Map.java b/map/Map.java index 7361e96..fed8441 100644 --- a/map/Map.java +++ b/map/Map.java @@ -2,7 +2,7 @@ package map; import priorityqueue.Entry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; public interface Map { diff --git a/partition/ListPartition.java b/partition/ListPartition.java index 64501c7..ed8ba84 100644 --- a/partition/ListPartition.java +++ b/partition/ListPartition.java @@ -7,7 +7,7 @@ import set.OrderedListSet; import set.Set; import utility.DefaultComparator; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Iterator; /** @@ -40,23 +40,18 @@ public class ListPartition implements Partition { @Override public Set makeSet(E x) { - try { + OrderedListSet o = new OrderedListSet(x, new DefaultComparator()); elementi.put(x, o); partizione.addLast(o); o.setLocation(partizione.last()); return o; - } - catch (InvalidKeyException e){ - - } - return null; } @Override public Set union(Set A, Set B) { - try { + if (A.size() > B.size()){ OrderedListSet AA = (OrderedListSet) A; OrderedListSet BB = (OrderedListSet) B; @@ -82,23 +77,13 @@ public class ListPartition implements Partition { } - } - catch (InvalidKeyException e){ - - } - return null; - } @Override public Set find(E x) { - try { - return elementi.get(x); - } - catch (InvalidKeyException e){ - } - return null; + return elementi.get(x); + } @Override diff --git a/priorityqueue/AdaptablePriorityQueue.java b/priorityqueue/AdaptablePriorityQueue.java index 46069a5..cfedb6d 100644 --- a/priorityqueue/AdaptablePriorityQueue.java +++ b/priorityqueue/AdaptablePriorityQueue.java @@ -3,7 +3,7 @@ package priorityqueue; import priorityqueue.Entry; import priorityqueue.PriorityQueue; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; /** * Created with MONSTER. diff --git a/priorityqueue/PriorityQueue.java b/priorityqueue/PriorityQueue.java index 361fec4..70c2868 100644 --- a/priorityqueue/PriorityQueue.java +++ b/priorityqueue/PriorityQueue.java @@ -1,7 +1,7 @@ package priorityqueue; import exceptions.EmptyPriorityQueueException; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; /** * Created with xgiovio.macbookair. diff --git a/priorityqueue/SortedListAdaptablePriorityQueue.java b/priorityqueue/SortedListAdaptablePriorityQueue.java index dcdfd19..b738df7 100644 --- a/priorityqueue/SortedListAdaptablePriorityQueue.java +++ b/priorityqueue/SortedListAdaptablePriorityQueue.java @@ -6,7 +6,7 @@ import exceptions.InvalidEntryException; import position.Position; import position.utility.DNode; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Comparator; import java.util.Iterator; diff --git a/priorityqueue/SortedListPriorityQueue.java b/priorityqueue/SortedListPriorityQueue.java index a512fb3..3eaa914 100644 --- a/priorityqueue/SortedListPriorityQueue.java +++ b/priorityqueue/SortedListPriorityQueue.java @@ -5,7 +5,7 @@ import position.NodePositionList; import position.Position; import utility.DefaultComparator; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Comparator; import java.util.Iterator; diff --git a/priorityqueue/UnsortedListPriorityQueue.java b/priorityqueue/UnsortedListPriorityQueue.java index 318c0e5..fcb5e6d 100644 --- a/priorityqueue/UnsortedListPriorityQueue.java +++ b/priorityqueue/UnsortedListPriorityQueue.java @@ -5,7 +5,7 @@ import position.NodePositionList; import position.Position; import utility.DefaultComparator; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Comparator; import java.util.Iterator; diff --git a/priorityqueue/heap/HeapAdaptablePriorityQueue.java b/priorityqueue/heap/HeapAdaptablePriorityQueue.java index 7cc7336..f1783c1 100644 --- a/priorityqueue/heap/HeapAdaptablePriorityQueue.java +++ b/priorityqueue/heap/HeapAdaptablePriorityQueue.java @@ -6,7 +6,7 @@ import priorityqueue.AdaptablePriorityQueue; import priorityqueue.Entry; import priorityqueue.MyEntry; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Comparator; /** diff --git a/priorityqueue/heap/HeapPriorityQueue.java b/priorityqueue/heap/HeapPriorityQueue.java index f516e72..42ac274 100644 --- a/priorityqueue/heap/HeapPriorityQueue.java +++ b/priorityqueue/heap/HeapPriorityQueue.java @@ -4,11 +4,12 @@ import position.Position; import priorityqueue.Entry; import priorityqueue.MyEntry; import priorityqueue.PriorityQueue; +import stack.NodeStack; import tree.binarytree.heap.ArrayListCompleteBinaryTree; import tree.binarytree.heap.CompleteBinaryTree; import utility.DefaultComparator; -import java.security.InvalidKeyException; +import exceptions.InvalidKeyException; import java.util.Comparator; @@ -28,7 +29,7 @@ public class HeapPriorityQueue implements PriorityQueue { comp = c; } - //elementi gia' ordinati + public HeapPriorityQueue (K k[], V v[], Comparator C){ heap = new ArrayListCompleteBinaryTree>(); comp = C; @@ -37,11 +38,22 @@ public class HeapPriorityQueue implements PriorityQueue { } else { + NodeStack>> s = new NodeStack>>(); for (int i = 0; i < k.length; i++) { - heap.add(new MyEntry(k[i],v[i])); // gia' ordinati. evitiamo l'upheap + ArrayListCompleteBinaryTree.BTPos> t = (ArrayListCompleteBinaryTree.BTPos>) heap.add(new MyEntry(k[i], v[i])); + s.push(t); } + + for (;!s.isEmpty();){ + ArrayListCompleteBinaryTree.BTPos> t = s.pop(); + if (!heap.isExternal(t)) + downHeap(t); + } + + } + } public void setComparator(Comparator c) throws IllegalStateException { diff --git a/test_2_prova_intercorso/ExBinaryTree_11_2_13.java b/test_2_prova_intercorso/ExBinaryTree_11_2_13.java new file mode 100644 index 0000000..ae2f8d9 --- /dev/null +++ b/test_2_prova_intercorso/ExBinaryTree_11_2_13.java @@ -0,0 +1,210 @@ +package test_2_prova_intercorso; + + + /* + + + + + L'albero T usato per il II test e` il seguente: + + + 4 + + / \ + 2 8 + / \ / \ + 1 3 4 10 + \ / \ + 7 2 11 + + + L'albero T usato per il III test e` il seguente: + + + 4 + + / \ + 2 8 + / \ / \ + 1 3 4 10 + \ \ / \ + 2 7 2 11 + + + L'albero T usato per il IV test e` il seguente: + + + 4 + + / \ + 2 8 + / \ / \ + 1 3 4 10 + \ / \ / \ + 8 5 7 2 11 + / \ + 1 40 + + + + +Il programma deve stampare: + + I test: Albero vuoto + + II test: L'albero soddisfa la proprieta`. + + III test: L'albero NON soddisfa la proprieta`. + + IV test: L'albero NON soddisfa la proprieta`. + + */ + +import exceptions.EmptyTreeException; +import exceptions.InvalidPositionException; +import position.Position; +import tree.binarytree.BTNode; +import tree.binarytree.BTPosition; +import tree.binarytree.BinaryTree; +import tree.binarytree.LinkedBinaryTree; + +public class ExBinaryTree_11_2_13 { + + public static void main(String[] args){ + ExamBinaryTree T= new ExamBinaryTree(); + + System.out.print("I test: "); + + try{check(T);} + catch(EmptyTreeException e) + {System.out.println("Albero vuoto");} + + T.examAddRoot(4); + T.examExpandExternal(T.root(), 2, 8 ); + T.examExpandExternal(T.left(T.root()), 1 , 3 ); + T.examExpandExternal(T.right(T.root()), 4 , 10 ); + T.examInsertRight(T.left(T.right(T.root())), 7 ); + T.examExpandExternal(T.right(T.right(T.root())), 2 , 11 ); + + System.out.print( "\nII test: "); + if(check(T)) System.out.println("L'albero soddisfa la proprieta`."); + else System.out.println("L'albero NON soddisfa la proprieta`."); + + T.examInsertRight(T.right(T.left(T.root())), 2); + System.out.print( "\nIII test: "); + if(check(T)) System.out.println("L'albero soddisfa la proprieta`."); + else System.out.println("L'albero NON soddisfa la proprieta`."); + + T.replace(T.right(T.right(T.left(T.root()))), 8); + T.examInsertLeft(T.left(T.right(T.root())),5); + T.examExpandExternal(T.left(T.left(T.right(T.root()))), 1, 40); + + System.out.print( "\nIV test: "); + if(check(T)) System.out.println("L'albero soddisfa la proprieta`."); + else System.out.println("L'albero NON soddisfa la proprieta`."); + + + } + + + + public static boolean exec_check(BinaryTree T, Position start) { + if (T.isExternal(start)) + return true; + else { + + if (T.hasLeft(start) && T.hasRight(start)){ + Integer leftv = T.left(start).element(); + Integer rightv = T.right(start).element(); + Integer myvalue = start.element(); + if (leftv < myvalue && rightv > myvalue) + return (true && exec_check (T,T.left(start)) && exec_check (T,T.right(start)) ) ; + return false; + } else { + if (T.hasLeft(start) && !T.hasRight(start)) { + Integer leftv = T.left(start).element(); + Integer myvalue = start.element(); + if (leftv < myvalue) + return (true && exec_check(T, T.left(start))); + return false; + } else { + Integer rightv = T.right(start).element(); + Integer myvalue = start.element(); + if ( rightv > myvalue) + return (true && exec_check (T,T.right(start)) ) ; + return false; + + } + + + } + } + + } + + //scrivere qui la funzione + public static boolean check(BinaryTree T){ + if (T.isEmpty()) + throw new EmptyTreeException(); + Position start = T.root(); + return exec_check (T,start) ; + + } + + + //Sostituire size con in nome della variabile di istanza che tiene + //traccia del numero di nodi nella vostra classe LinkedBinaryTree + public static class ExamBinaryTree extends LinkedBinaryTree implements BinaryTree{ + + + public Position examAddRoot(E e){// throws NonEmptyTreeException { + // if(!isEmpty()) + // throw new NonEmptyTreeException("L'albero ha gia una radice"); + size = 1; + root = examCreateNode(e,null,null,null); + return root; + } + + protected BTPosition examCreateNode(E element, BTPosition parent, + BTPosition left, BTPosition right) { + return new BTNode(element,parent,left,right); } + + public void examExpandExternal(Position v, E l, E r) + throws InvalidPositionException { + if (!isExternal(v)) + throw new InvalidPositionException("Il nodo non e` una foglia"); + examInsertLeft(v, l); + examInsertRight(v, r); + } + + + public Position examInsertLeft(Position v, E e) + throws InvalidPositionException { + BTPosition vv = checkPosition(v); + Position leftPos = vv.getLeft(); + if (leftPos != null) + throw new InvalidPositionException("il nodo ha gia` un figlio sin"); + BTPosition ww = examCreateNode(e, vv, null, null); + vv.setLeft(ww); + size++; + return ww; + } + public Position examInsertRight(Position v, E e) + throws InvalidPositionException { + BTPosition vv = checkPosition(v); + Position rightPos = vv.getRight(); + if (rightPos != null) + throw new InvalidPositionException("il nodo ha gia` un figlio destro"); + BTPosition w = examCreateNode(e, vv, null, null); + vv.setRight(w); + size++; + return w; + } + + + + + } + +} \ No newline at end of file diff --git a/test_2_prova_intercorso/ExGraph_15_6PerEserc.java b/test_2_prova_intercorso/ExGraph_15_6PerEserc.java new file mode 100644 index 0000000..42eec7f --- /dev/null +++ b/test_2_prova_intercorso/ExGraph_15_6PerEserc.java @@ -0,0 +1,164 @@ +package test_2_prova_intercorso; + + +/*Il programma deve stampare : + +Test su un grafo che NON contiene cicli di lunghezza 3 passanti per il vertice 0: +Il grafo contiene i vertici: 0 1 2 3 4 5 6 7 8 +e gli archi: (0,1)(0,2)(0,3)(1,4)(1,5)(1,6)(2,5)(2,6)(3,6)(4,6)(4,7)(4,8)(5,7)(5,8)(6,8) + +Se invochiamo removeClosestVertices sul vertice 0 vengono cancellati i vertici: +4 5 6 1 2 3 + +Test su un grafo che contiene cicli di lunghezza 3 passanti per il vertice 0: +Il grafo contiene i vertici: 0 1 2 3 4 5 6 7 8 +e gli archi: (0,1)(0,2)(0,3)(0,4)(0,5)(1,4)(1,5)(1,6)(2,5)(2,6)(3,6)(4,6)(4,7)(4,8)(5,7)(5,8)(6,8) + +Se invochiamo removeClosestVertices sul vertice 0 vengono cancellati i vertici: +6 1 2 3 7 8 4 5 + + +*PS: ovviamente i vertici e gli archi potrebbero essere stampati in un diverso ordine +*/ + + +import graph.AdjacencyListGraph; +import graph.Edge; +import graph.Graph; +import graph.Vertex; +import position.NodePositionList; +import position.PositionList; + +import java.util.Iterator; + +public class ExGraph_15_6PerEserc { + public static void main(String[] args){ + AdjacencyListGraph G1= new AdjacencyListGraph(); + AdjacencyListGraph G2= new AdjacencyListGraph(); + + //I test + System.out.println("\n\nTest su un grafo che NON contiene cicli di lunghezza 3 passanti per il vertice 0:"); + System.out.print("Il grafo contiene i vertici: "); + + Vertex[] A= (Vertex[]) new Vertex[9]; + for(int i=0;i<=8;i++) + A[i]=G1.insertVertex(i); + + for(int i= 1;i<4;i++) + G1.insertEdge(A[0], A[i], null); + + for(int i=1;i<=3;i++){ + for(int j= i+3;j<7;j++) + G1.insertEdge(A[i], A[j], null); + } + for(int i=4;i<9;i++){ + for(int j= i+2;j<9;j++) + G1.insertEdge(A[i], A[j], null); + } + + + Iterator> itV=G1.vertices().iterator(); + while(itV.hasNext()) + System.out.print(itV.next().element()+" "); + + System.out.print("\ne gli archi: "); + Iterator> itE=G1.edges().iterator(); + while(itE.hasNext()){ + Edge e= itE.next(); + System.out.print("("+G1.endVertices(e)[0].element()+","+G1.endVertices(e)[1].element()+")"); + } + + + itV=removeClosestVertices(G1,A[0]).iterator(); + System.out.println("\n\nSe invochiamo removeClosestVertices sul vertice 0 vengono cancellati i vertici:"); + + while(itV.hasNext()) + System.out.print(itV.next()+" "); + + + //II test + System.out.println("\n\nTest su un grafo che contiene cicli di lunghezza 3 passanti per il vertice 0:"); + System.out.print("Il grafo contiene i vertici: "); + + for(int i=0;i<=8;i++) + A[i]=G2.insertVertex(i); + + for(int i= 1;i<6;i++) + G2.insertEdge(A[0], A[i], null); + + for(int i=1;i<=3;i++){ + for(int j= i+3;j<7;j++) + G2.insertEdge(A[i], A[j], null); +} + for(int i=4;i<8;i++){ + for(int j= i+2;j<9;j++) + G2.insertEdge(A[i], A[j], null); +} + + itV=G2.vertices().iterator(); + while(itV.hasNext()) + System.out.print(itV.next().element()+" "); + + System.out.print("\ne gli archi: "); + itE=G2.edges().iterator(); + while(itE.hasNext()){ + Edge e= itE.next(); + System.out.print("("+G2.endVertices(e)[0].element()+","+G2.endVertices(e)[1].element()+")"); + } + + + itV=removeClosestVertices(G2,A[0]).iterator(); + System.out.println("\n\nSe invochiamo removeClosestVertices sul vertice 0 vengono cancellati i vertici:"); + + while(itV.hasNext()) + System.out.print(itV.next()+" "); + + + + } + + public static boolean notpresentin (Vertex v, PositionList> list ){ + + Iterator> it = list.iterator(); + for (;it.hasNext();){ + if (v.equals(it.next())) + return false; + } + return true; + } + + + //scrivere qui la funzione + public static Iterable> removeClosestVertices(Graph G,Vertex v){ + NodePositionList> vertex_list = new NodePositionList>(); + + Iterator> it = G.incidentEdges(v).iterator(); + for (;it.hasNext();){ + vertex_list.addLast(G.opposite( v, it.next() ) ); + } + Iterator> it2 = vertex_list.iterator(); + for (;it2.hasNext();){ + Vertex t = it2.next(); + Iterator> it3 = G.incidentEdges(t).iterator(); + for (;it3.hasNext();){ + Edge t2 = it3.next(); + Vertex t3 = G.opposite( t, t2 ); + if (!t3.equals(v) && notpresentin (t3,vertex_list)){ + vertex_list.addFirst(t3); + } + } + } + + + + Iterator> it4 = vertex_list.iterator(); + + Vertex t = it4.next(); + G.removeVertex(t); + + + return vertex_list; + + } + +} diff --git a/test_2_prova_intercorso/ExMap15_1.java b/test_2_prova_intercorso/ExMap15_1.java new file mode 100644 index 0000000..807eba3 --- /dev/null +++ b/test_2_prova_intercorso/ExMap15_1.java @@ -0,0 +1,117 @@ +package test_2_prova_intercorso; + +/*Il programma deve stampare (ovviamente le entrate di M e D possono essere stampate in un diverso ordine): +I test: +M e` vuota +D = < (50,29) (50,39) (50,49) (70,39) (70,49) (70,59) (70,69) (90,49) (90,59) (90,69) (90,79) (90,89) (10,9) (30,19) (30,29) > +Dopo aver invocato addEntries su M e D, si ha M=< (90,49) (70,39) (50,29) (30,19) (10,9) > + +II test: +M=< (90,49) (70,39) (50,29) (30,19) (10,9) > +D = < (50,29) (50,39) (50,49) (50,28) (70,39) (70,49) (70,59) (70,69) (70,38) (90,49) (90,59) (90,69) (90,79) (90,89) (90,48) (10,9) (10,8) (30,19) (30,29) (30,18) >. +Nota che la mappa M contiene le entrate inserite dalla prima chiamata di addEntries +e che al dizionario D sono state aggiunte le entrate (50,28) (30,18) (90,48) (10,8) (70,38). +Dopo aver invocato addEntries su M e D, si ha M=< (90,49) (70,39) (50,29) (30,19) (10,9) >. + + */ + + +import dictionary.Dictionary; +import dictionary.LinearProbingHashTable; +import exceptions.InvalidKeyException; +import map.HashTableMap; +import map.Map; +import priorityqueue.Entry; + +import java.util.Comparator; +import java.util.Iterator; + +public class ExMap15_1 { + public static void main(String[] args){ + Map M = new HashTableMap(); + Dictionary D= new LinearProbingHashTable(); + + + System.out.println("I test:"); + System.out.println("M e` vuota "); + for(int i=10;i<100;i=i+20) + for(int j=i/2+4;j> itD= D.entries().iterator(); + System.out.print("D = < "); + while(itD.hasNext()) + System.out.print(itD.next()+" "); + System.out.println(">"); + + addEntries(M,D,new IntegerComparator()); + Iterator> itM= M.entries().iterator(); + System.out.print("Dopo aver invocato addEntries su M e D, si ha M=< "); + while(itM.hasNext()) + System.out.print(itM.next()+" "); + System.out.println(">"); + + + System.out.println("\nII test: "); + itM= M.entries().iterator(); + System.out.print("M=< "); + while(itM.hasNext()) + System.out.print(itM.next()+" "); + System.out.println(">"); + for(int i=10;i<100;i=i+20) + D.insert(i, i/2+3); + itD= D.entries().iterator(); + System.out.print("D = < "); + while(itD.hasNext()) + System.out.print(itD.next()+" "); + System.out.println(">."); + System.out.println("Nota che la mappa M contiene le entrate inserite dalla prima chiamata di addEntries"); + System.out.println("e che al dizionario D sono state aggiunte le entrate (50,28) (30,18) (90,48) (10,8) (70,38)."); + addEntries(M,D,new IntegerComparator()); + itM= M.entries().iterator(); + System.out.print("Dopo aver invocato addEntries su M e D, si ha M=< "); + while(itM.hasNext()) + System.out.print(itM.next()+" "); + System.out.println(">."); + + + + } + + + //scrivere qui la funzione + public static void addEntries(Map M, Dictionary D, Comparator c){ + + Iterator> it = D.entries().iterator(); + for (;it.hasNext();){ + Entry e = it.next(); + K key = e.getKey(); + K value = null; + if (M.get(key) == null ){ + Iterator> it2 = D.findAll(key).iterator(); + int flag = 0; + for (;it2.hasNext();){ + Entrye2 = it2.next(); + if (flag == 0){ + flag = 1; + value = e2.getValue(); + } else { + if ( c.compare( e2.getValue(),value) < 0 ){ + value = e2.getValue(); + } + } + + } + M.put(key,value); + } + } + } + + + public static class IntegerComparator implements Comparator { + + public int compare(Integer a, Integer b) throws ClassCastException { + return(a-b); + + } +} +} \ No newline at end of file diff --git a/test_2_prova_intercorso/ExPQ_21_2_11.java b/test_2_prova_intercorso/ExPQ_21_2_11.java index 45ff162..3028db4 100755 --- a/test_2_prova_intercorso/ExPQ_21_2_11.java +++ b/test_2_prova_intercorso/ExPQ_21_2_11.java @@ -27,8 +27,10 @@ Dopo aver invocato subtract(Q1,Q2), la coda a priorita` Q1 contiene le entrate: import java.security.InvalidKeyException; import java.util.Comparator; +import java.util.Iterator; +import position.NodePositionList; import priorityqueue.Entry; import priorityqueue.PriorityQueue; import priorityqueue.heap.HeapPriorityQueue; @@ -105,61 +107,44 @@ public class ExPQ_21_2_11 { public static void subtract (PriorityQueue Q1, PriorityQueue Q2,Comparatorc ) throws InvalidKeyException{ - if (Q1== null || Q2 == null || Q1.size() == 0 || Q2.size() == 0) + if( Q1.isEmpty() || Q2.isEmpty() ) throw new EmptyPriorityQueueException(); - PriorityQueue tempq = new HeapPriorityQueue(); + Entry a = Q1.removeMin(); + Entry b = Q2.removeMin(); - Entry t = Q1.removeMin(); - Entry t2 = Q2.removeMin(); + NodePositionList> t = new NodePositionList>(); + for(;;){ - for (; ;){ - - int result = c.compare( t.getKey(),t2.getKey()); - - if (result < 0) { - tempq.insert(t.getKey(), t.getValue()); - if (Q1.size() > 0) { - t = Q1.removeMin(); + if (c.compare(a.getKey(),b.getKey()) < 0){ + t.addLast(a); + if (!Q1.isEmpty()){ + a=Q1.removeMin(); continue; - } else { - break; - } + }else break; } - if (result == 0){ - if (Q1.size() > 0) { - t = Q1.removeMin(); + if (c.compare(a.getKey(),b.getKey()) == 0){ + if (!Q1.isEmpty()){ + a=Q1.removeMin(); continue; - } else { - break; - } - + }else break; } - if ( result > 0){ - if (Q2.size() > 0) { - - t2 = Q2.removeMin(); + if (c.compare(a.getKey(),b.getKey()) > 0){ + if (!Q2.isEmpty()){ + b=Q2.removeMin(); continue; - }else { - break; - } - + }else break; } - - - - } - - - for ( ;tempq.size() > 0 ;){ - t = tempq.removeMin(); - Q1.insert(t.getKey(), t.getValue()); - } + Iterator> it = t.iterator(); + for (;it.hasNext();){ + Entry e = it.next(); + Q1.insert(e.getKey(),e.getValue()); + } } diff --git a/test_2_prova_intercorso/ExTree_17_1_2013.java b/test_2_prova_intercorso/ExTree_17_1_2013.java new file mode 100644 index 0000000..3723094 --- /dev/null +++ b/test_2_prova_intercorso/ExTree_17_1_2013.java @@ -0,0 +1,186 @@ +package test_2_prova_intercorso; + + +import exceptions.EmptyTreeException; +import position.NodePositionList; +import position.Position; +import position.PositionList; +import tree.LinkedTree; +import tree.Tree; +import tree.TreeNode; +import tree.TreePosition; + +import java.util.Iterator; + +/***** + * L'albero usato per il II test e` + * + * 9 + * / / \ \ + * 10 11 12 13 + * / | \ / / \ \ + * 2 3 4 8 7 6 10 + * | / | \ + * 10 11 10 9 + * + * + + Il programma deve stampare: + + I test + L'albero e` vuoto. + + + II test: T e` l'albero disegnato all'inizio del file. + + I primi 2 nodi contenenti 10 sono: + il nodo avente come padre il nodo contenente 9 e come figli i nodi contenenti gli elementi 2, 3, 4, + il nodo avente come padre il nodo contenente 4 + + I primi 3 nodi contenenti 10 sono: + il nodo avente come padre il nodo contenente 9 e come figli i nodi contenenti gli elementi 2, 3, 4, + il nodo avente come padre il nodo contenente 4 + il nodo avente come padre il nodo contenente 6 + + I primi 4 nodi contenenti 10 sono: + il nodo avente come padre il nodo contenente 9 e come figli i nodi contenenti gli elementi 2, 3, 4, + il nodo avente come padre il nodo contenente 4 + il nodo avente come padre il nodo contenente 6 + il nodo avente come padre il nodo contenente 13 + + I primi 5 nodi contenenti 10 sono: + il nodo avente come padre il nodo contenente 9 e come figli i nodi contenenti gli elementi 2, 3, 4, + il nodo avente come padre il nodo contenente 4 + il nodo avente come padre il nodo contenente 6 + il nodo avente come padre il nodo contenente 13 + */ + +public class ExTree_17_1_2013 { + + public static void main(String[]args){ + + ExamTree T = new ExamTree(); + + + + System.out.println("I test"); + try{ + select(T,5,4); + } + catch(EmptyTreeException e){ + System.out.println("L'albero e` vuoto.\n"); + } + + + + + T.examAddRoot(9); + for(int i=10;i<=13 ; i++) + T.examAddChild(i, T.root()); + + Iterator> figliRadice= T.children(T.root()).iterator(); + Position figlioRadice = figliRadice.next(); + Position figlio=null; + for(int j=1;j<=3;j++) + figlio = T.examAddChild(+(1+j), figlioRadice); + T.examAddChild(10, figlio); + figliRadice.next(); + figliRadice.next(); + figlioRadice = figliRadice.next(); + Position nipoteRadice=null; + for(int j=1;j<=3;j++) + nipoteRadice=T.examAddChild((9-j), figlioRadice); + T.examAddChild(10, figlioRadice); + for(int j=11;j>=9;j--) + T.examAddChild( j, nipoteRadice); + + + + + + + System.out.println("\nII test: T e` l'albero disegnato all'inizio del file."); + + for(int k=2;k<6;k++){ + System.out.print("\nI primi "+ k +" nodi contenenti 10 sono: "); + + for(Position p: select(T,10,k)){ + if(T.isRoot(p))System.out.print("\nil nodo radice, "); + else System.out.print("\nil nodo avente come padre il nodo contenente "+ T.parent(p).element()); + if(T.isInternal(p)){ + System.out.print(" e come figli i nodi contenenti gli elementi "); + for(Position child : T.children(p)) + System.out.print(child.element()+", "); + + + } + } + System.out.println(); + } + } + + + + public static void exec_select (Tree T, Position start, E x, int k, PositionList> l) { + + if (start.element().equals(x) && l.size() < k) + l.addLast(start); + if (l.size() < k && !T.isExternal(start)){ + Iterator>it = T.children(start).iterator(); + for (;it.hasNext();){ + Position t = it.next(); + exec_select(T,t,x,k,l); + } + } + + + } + + + //scrivere qui la funzione + public static Iterable > select(Tree T, E x, int k){ + if (T.isEmpty()) throw new EmptyTreeException(); + NodePositionList> to_return = new NodePositionList>(); + exec_select(T,T.root(),x ,k,to_return); + return to_return; + + } + + + public static class ExamTree extends LinkedTree implements Tree{ + + public Position examAddRoot(E e){// throws NonEmptyTreeException { + // if(!isEmpty()) + // throw new NonEmptyTreeException("L'albero ha gia` una radice"); + size = 1; + root = examCreateNode(e,null,null); + return root; + } + + + //aggiunge a v un figlio che ha come elemento element + public Position examAddChild(E element,Position v){ + size++; + Position newP= examCreateNode(element,(TreePosition) v,null); + if(isExternal(v)){ + PositionList> figli = new NodePositionList>(); + ((TreePosition) v).setChildren(figli); + figli.addLast(newP);} + else((PositionList>)children(v)).addLast(newP); + return newP; + } + + protected TreePosition examCreateNode(E element, TreePosition parent, + PositionList> children) { + return new TreeNode(element,parent,children); + } + + } + + + + + + + + } diff --git a/test_2_prova_intercorso/General.java b/test_2_prova_intercorso/General.java new file mode 100644 index 0000000..11636de --- /dev/null +++ b/test_2_prova_intercorso/General.java @@ -0,0 +1,82 @@ +package test_2_prova_intercorso; + +import exceptions.InvalidKeyException; +import graph.ComponentsBFS; +import graph.Edge; +import graph.Graph; +import graph.Vertex; +import partition.ListPartition; +import partition.Partition; +import position.NodePositionList; + +/** + * Created with MONSTER. + * User: xgiovio + * Date: 01/06/2014 + * Time: 17:32 + */ +public class General { + + public static Partition> findConnectedComponentsl(Graph G){ + + + Partition> p = new ListPartition>(); + + Object VISITED = new Object(); + Object UNVISITED = new Object(); + Object STATUS = + for (Vertex v : G.vertices()) { + v.put() + } + + + + layers.add(0, new NodePositionList>()); + layers.get(0).addLast(v); + } + + int i = 0; + while (!layers.get(i).isEmpty()) { + layers.add(i + 1, new NodePositionList>()); + + for (Vertex vertexInLayer : layers.get(i)) { + for (Edge e : graph.incidentEdges(vertexInLayer)) { + if (!isVisited(e)) { + visit(e); + Vertex w = graph.opposite(vertexInLayer, e); + if (!isVisited(w)) { + traverseDiscovery(e, vertexInLayer); + + if (isDone()) + break; + + visit(w); + layers.get(i + 1).addLast(w); + + if (isDone()) + break; + } else { + traverseCross(e, v); + if (isDone()) + break; + } + } + } + + if (!isDone()) + finishVisit(vertexInLayer); + } + + i++; + } + + return result(); + } + + + + } + + + +} diff --git a/tree/binarytree/heap/ArrayListCompleteBinaryTree.java b/tree/binarytree/heap/ArrayListCompleteBinaryTree.java index 86907be..c21dddc 100644 --- a/tree/binarytree/heap/ArrayListCompleteBinaryTree.java +++ b/tree/binarytree/heap/ArrayListCompleteBinaryTree.java @@ -153,7 +153,7 @@ public class ArrayListCompleteBinaryTree implements CompleteBinaryTree { // internal class - protected static class BTPos implements Position { + public static class BTPos implements Position { E element; int index; public BTPos(E elt, int i) {