ysimard/be_graphes
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Compare commits

base: ysimard:539ea33752df774ebc8f891772171eb89441964f
Branches Tags
ysimard:master
..
compare: ysimard:db095f9ea970f42d544e84059d9f529473428b1d
Branches Tags
ysimard:master

No commits in common. "539ea33752df774ebc8f891772171eb89441964f" and "db095f9ea970f42d544e84059d9f529473428b1d" have entirely different histories.
539ea33752 ... db095f9ea9

5 changed files with 41 additions and 45 deletions
Show stats Expand all files Collapse all files

8
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
View file

@ -56,10 +56,7 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
Node destination = data.getDestination();
Node currentNode = null;
// Debug / Tests
double previousCost = 0;
int iterationCounter = 0;
while (!heap.isEmpty() && (currentNode == null || !currentNode.equals(destination))) {
// Get the node with the minimum cost
@ -68,12 +65,11 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
currentNode = currentLabel.getNode();
/*
// Debug / Tests
// Debug
assert(((BinaryHeap<Label>) heap).isValid());
assert(currentLabel.getTotalCost() >= previousCost);
previousCost = currentLabel.getCost();
*/
iterationCounter++;
for (Arc arc : currentNode.getSuccessors()) {
Node dest = arc.getDestination();
@ -115,8 +111,6 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
currentLabel = labels.get(arc.getOrigin().getId());
}
System.out.printf("Nombre de sommets explorés : %d\n", iterationCounter);
Collections.reverse(path);
return new ShortestPathSolution(data, AbstractSolution.Status.OPTIMAL, new Path(data.getGraph(), path));

69
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/utils/BinaryHeap.java
View file

@ -1,15 +1,13 @@
package org.insa.graphs.algorithm.utils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
/**
* Implements a binary heap containing elements of type E.
* <p>
*
* Note that all comparisons are based on the compareTo method, hence E must
* implement Comparable
*
*
* @author Mark Allen Weiss
* @author DLB
*/
@ -17,7 +15,6 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
// Number of elements in heap.
private int currentSize;
private Map<E, Integer> elementIndexes = new HashMap<>();
// The heap array.
protected final ArrayList<E> array;
@ -32,18 +29,16 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Construct a copy of the given heap.
*
*
* @param heap Binary heap to copy.
*/
public BinaryHeap(BinaryHeap<E> heap) {
this.currentSize = heap.currentSize;
this.array = new ArrayList<E>(heap.array);
this.elementIndexes = new HashMap<>(heap.elementIndexes);
}
/**
* Check if each element is lower than its children
*
* @return true if valid, false otherwise
*/
public boolean isValid() {
@ -67,15 +62,15 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Set an element at the given index.
*
*
* @param index Index at which the element should be set.
* @param value Element to set.
*/
private void arraySet(int index, E value) {
elementIndexes.put(value, index);
if (index == this.array.size()) {
this.array.add(value);
} else {
}
else {
this.array.set(index, value);
}
}
@ -103,13 +98,15 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Internal method to percolate up in the heap.
*
*
* @param index Index at which the percolate begins.
*/
private void percolateUp(int index) {
E x = this.array.get(index);
for (; index > 0 && x.compareTo(this.array.get(indexParent(index))) < 0; index = indexParent(index)) {
for (; index > 0
&& x.compareTo(this.array.get(indexParent(index))) < 0; index = indexParent(
index)) {
E moving_val = this.array.get(indexParent(index));
this.arraySet(index, moving_val);
}
@ -119,7 +116,7 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Internal method to percolate down in the heap.
*
*
* @param index Index at which the percolate begins.
*/
private void percolateDown(int index) {
@ -139,7 +136,8 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
this.arraySet(ileft, current);
this.percolateDown(ileft);
}
} else {
}
else {
// Right is smaller
if (right.compareTo(current) < 0) {
this.arraySet(index, right);
@ -169,14 +167,21 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
@Override
public void remove(E x) throws ElementNotFoundException {
Integer index = elementIndexes.remove(x);
if (index == null) throw new ElementNotFoundException(x);
currentSize--;
if (currentSize != 0 && index != currentSize) {
arraySet(index, array.get(currentSize));
percolateUp(index);
percolateDown(index);
int index = 0;
// We avoid array.indexOf(x) because we don't need to search
// through the whole list, we can stop at indexSize.
boolean found = false;
while(!found && index < currentSize) {
if (array.get(index) == x)
found =true;
else
index++;
}
if (!found) throw new ElementNotFoundException(x);
arraySet(index, array.get(--currentSize));
percolateUp(index);
percolateDown(index);
}
@Override
@ -189,19 +194,15 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
@Override
public E deleteMin() throws EmptyPriorityQueueException {
E minItem = findMin();
elementIndexes.remove(minItem);
currentSize--;
if (currentSize != 0) {
E lastItem = this.array.get(this.currentSize);
this.arraySet(0, lastItem);
this.percolateDown(0);
}
E lastItem = this.array.get(--this.currentSize);
this.arraySet(0, lastItem);
this.percolateDown(0);
return minItem;
}
/**
* Creates a multi-lines string representing a sorted view of this binary heap.
*
*
* @return a string containing a sorted view this binary heap.
*/
public String toStringSorted() {
@ -210,9 +211,10 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Creates a multi-lines string representing a sorted view of this binary heap.
*
*
* @param maxElement Maximum number of elements to display. or {@code -1} to
* display all the elements.
*
* @return a string containing a sorted view this binary heap.
*/
public String toStringSorted(int maxElement) {
@ -221,7 +223,7 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Creates a multi-lines string representing a tree view of this binary heap.
*
*
* @return a string containing a tree view of this binary heap.
*/
public String toStringTree() {
@ -230,8 +232,9 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
/**
* Creates a multi-lines string representing a tree view of this binary heap.
*
*
* @param maxDepth Maximum depth of the tree to display.
*
* @return a string containing a tree view of this binary heap.
*/
public String toStringTree(int maxDepth) {

2
be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithmTest.java
View file

@ -4,7 +4,7 @@ package org.insa.graphs.algorithm.shortestpath;
public class AStarAlgorithmTest extends ShortestPathTest {
@Override
protected ShortestPathSolution runShortestPathAlgo(ShortestPathData data) {
return new AStarAlgorithm(data).run();
return new AStarAlgorithm(data).doRun();
}
}

2
be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithmTest.java
View file

@ -3,6 +3,6 @@ package org.insa.graphs.algorithm.shortestpath;
public class DijkstraAlgorithmTest extends ShortestPathTest {
@Override
protected ShortestPathSolution runShortestPathAlgo(ShortestPathData data) {
return new DijkstraAlgorithm(data).run();
return new DijkstraAlgorithm(data).doRun();
}
}

5
be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/ShortestPathTest.java
View file

@ -62,7 +62,7 @@ public abstract class ShortestPathTest {
for (ArcInspector arcInspector : arcInspectors) {
ShortestPathData data = createData(maps[i], arcInspector, origIndexes[i], destIndexes[i]);
ShortestPathSolution sol = runShortestPathAlgo(data);
ShortestPathSolution oracle = new BellmanFordAlgorithm(data).run();
ShortestPathSolution oracle = new BellmanFordAlgorithm(data).doRun();
assertTrue(sol.isFeasible());
Path path = sol.getPath();
assertTrue(path.isValid());
@ -71,8 +71,7 @@ public abstract class ShortestPathTest {
assertEquals(path, Path.createShortestPathFromNodes(data.getGraph(), path.getNodes()));
if (i == 1)
assertEquals(path, Path.createFastestPathFromNodes(data.getGraph(), path.getNodes()));
// Check result against Bellman Ford algorithm (except for the square map
// where there may be several paths with the same cost)
// Check result against Bellman Ford algorithm (except for the square map or there may be several paths with the same cost)
if (i != 0)
assertEquals(sol.getPath(), oracle.getPath());
System.out.println();