diff --git a/src/main/java/fr/univamu/sorting/CountingSortable.java b/src/main/java/fr/univamu/sorting/CountingSortable.java
new file mode 100644
index 0000000000000000000000000000000000000000..43bf9d2424c4605b2c08a820149729d28e4b846a
--- /dev/null
+++ b/src/main/java/fr/univamu/sorting/CountingSortable.java
@@ -0,0 +1,53 @@
+package fr.univamu.sorting;
+
+import java.util.List;
+
+public class CountingSortable<T extends Comparable<T>> extends SortableDecorator<T> {
+
+ private Sortable<T> values;
+ public static int countingSwaps = 0;
+ public static int countingCompare = 0;
+
+ public CountingSortable( Sortable<T> values) {
+ super(values);
+ }
+
+
+ public int size(){
+ return super.size();
+ }
+
+ public T get(int index){
+ return super.get(index);
+ }
+
+
+ public void swap (int index1, int index2){
+ countingSwaps++;
+ super.swap(index1,index2);
+
+ }
+
+ public int compare (int index1, int index2){
+ countingCompare ++;
+ return super.compare(index1,index2);
+
+ }
+
+
+ public void set(int index, T value) {
+ super.set(index, value);
+ }
+
+ public List<T> getSortableParameter() {
+ return super.getSortableParameter();
+ }
+
+ public int getCountingCompare() {
+ return countingCompare;
+ }
+
+ public int getCountingSwaps(){
+ return countingSwaps;
+ }
+}
diff --git a/src/main/java/fr/univamu/sorting/InsertionSort.java b/src/main/java/fr/univamu/sorting/InsertionSort.java
index 43dd3002e6c04572399d568942244ca3ef08f557..669138f120b627c932e29c0c910d8519526358b3 100644
--- a/src/main/java/fr/univamu/sorting/InsertionSort.java
+++ b/src/main/java/fr/univamu/sorting/InsertionSort.java
@@ -1,19 +1,19 @@
package fr.univamu.sorting;
-public class InsertionSort implements Sorter{
- private final Sortable sortable;
- public InsertionSort( Sortable sortable){
+public class InsertionSort<T extends Comparable<T>> implements Sorter<T>{
+ private final Sortable<T> sortable;
+ public InsertionSort( Sortable<T> sortable){
this.sortable = sortable;
}
public void sort() {
int n = sortable.size();
for (int i = 1; i < n; ++i) {
- int presentElement = sortable.get(i);
+ T presentElement = sortable.get(i);
int j = i - 1;
- while (j >= 0 && sortable.get(j) > presentElement) {
+ while (j >= 0 && sortable.compare(j,i) > 0) {
sortable.set(j + 1, sortable.get(j));
j = j - 1;
}
@@ -21,7 +21,8 @@ public class InsertionSort implements Sorter{
}
}
- public Sortable getSortable (){
+
+ public Sortable<T> getSortable (){
return sortable;
}
diff --git a/src/main/java/fr/univamu/sorting/LoggingSortable.java b/src/main/java/fr/univamu/sorting/LoggingSortable.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c9f91247a9e620d8cd0ebb92f09ebbdf6e6a368
--- /dev/null
+++ b/src/main/java/fr/univamu/sorting/LoggingSortable.java
@@ -0,0 +1,52 @@
+package fr.univamu.sorting;
+
+import java.io.PrintStream;
+import java.util.List;
+
+public class LoggingSortable<T extends Comparable<T>> extends SortableDecorator<T> {
+
+ private Sortable<T> values;
+ private PrintStream logStream;
+
+ public LoggingSortable (Sortable<T> values){
+ super(values);
+ }
+
+
+ @Override
+ public void swap(int index1, int index2) {
+ super.swap(index1, index2);
+ logStream.println("swap : "+index1+" et "+index2);
+ }
+
+ @Override
+ public int compare(int index1, int index2) {
+ logStream.println("Compare : "+index1+" et "+index2);
+ return super.compare(index1,index2);
+
+ }
+
+ @Override
+ public int size() {
+ return super.size();
+ }
+
+ @Override
+ public T get(int index) {
+ return super.get(index);
+ }
+
+ @Override
+ public void set(int index, T value) {
+ super.set(index, value);
+ }
+
+ @Override
+ public List<T> getSortableParameter() {
+ return super.getSortableParameter();
+ }
+
+ public PrintStream getLogStream() {
+ return logStream;
+ }
+}
diff --git a/src/main/java/fr/univamu/sorting/QuickSort.java b/src/main/java/fr/univamu/sorting/QuickSort.java
index f0e7002af0837d969a4c5e2ee540563edd7c38db..d3d66e9de8b5fe3e1dbb672d6c5bb10841bfa8c9 100644
--- a/src/main/java/fr/univamu/sorting/QuickSort.java
+++ b/src/main/java/fr/univamu/sorting/QuickSort.java
@@ -2,20 +2,20 @@ package fr.univamu.sorting;
-public class QuickSort implements Sorter {
- private final Sortable sortable;
+public class QuickSort<T extends Comparable<T>> implements Sorter<T> {
+ private final Sortable<T> sortable;
- public QuickSort(Sortable sortable) {
+ public QuickSort(Sortable<T> sortable) {
this.sortable = sortable;
}
private int partition(int start , int end) {
- int pivot = sortable.get(end);
+ //T pivot = sortable.get(end);
int i = start - 1;
for (int j = start; j < end; j++) {
- int bool = sortable.compare(sortable.get(j),pivot);
- if (bool == -1 || bool==0){
+ int bool = sortable.compare(j,end);
+ if (bool <= 0){
i++;
sortable.swap(i, j);
}
@@ -42,7 +42,7 @@ public class QuickSort implements Sorter {
}
- public Sortable getSortable (){
+ public Sortable<T> getSortable (){
return sortable;
}
diff --git a/src/main/java/fr/univamu/sorting/Sortable.java b/src/main/java/fr/univamu/sorting/Sortable.java
index 5c9f004b97c70054cb0e91177872d84e4d21d3d3..2049048c164d3ba5ccbb2ea23599efa89a36df7b 100644
--- a/src/main/java/fr/univamu/sorting/Sortable.java
+++ b/src/main/java/fr/univamu/sorting/Sortable.java
@@ -2,18 +2,18 @@ package fr.univamu.sorting;
import java.util.List;
-public interface Sortable {
+public interface Sortable<T extends Comparable<T>> {
void swap (int index1, int index2);
- int compare (int index1, int index2);
+ int compare (int index1, int index2);
int size();
- int get( int index);
+ T get( int index);
- void set(int index, int value);
+ void set(int index,T value);
- List<Integer> getSortableParameter();
+ List<T> getSortableParameter();
}
diff --git a/src/main/java/fr/univamu/sorting/SortableDecorator.java b/src/main/java/fr/univamu/sorting/SortableDecorator.java
new file mode 100644
index 0000000000000000000000000000000000000000..3709e8d497b1be43f8776fc8b7f9b3ba6b429202
--- /dev/null
+++ b/src/main/java/fr/univamu/sorting/SortableDecorator.java
@@ -0,0 +1,42 @@
+package fr.univamu.sorting;
+
+import java.util.List;
+
+public abstract class SortableDecorator<T extends Comparable<T>> implements Sortable<T>{
+ private final Sortable<T> values;
+ public SortableDecorator (Sortable<T> sortables){
+ this.values = sortables;
+ }
+
+
+ @Override
+ public int size() {
+ return values.size();
+ }
+
+ @Override
+ public T get(int index) {
+ return values.get(index);
+ }
+
+ @Override
+ public void set(int index, T value) {
+ values.set(index,value);
+ }
+
+ @Override
+ public List<T> getSortableParameter() {
+ return values.getSortableParameter();
+ }
+
+ @Override
+ public int compare(int index1, int index2) {
+ return values.compare(index1,index1);
+ }
+
+ @Override
+ public void swap(int index1, int index2) {
+ values.swap(index1,index2);
+ }
+}
+
diff --git a/src/main/java/fr/univamu/sorting/SortableIntArray.java b/src/main/java/fr/univamu/sorting/SortableIntArray.java
index 62e3bac79a93aacc4722633a431282d184765f9b..997b47014329810cf82326b4fb04f8f17708ab14 100644
--- a/src/main/java/fr/univamu/sorting/SortableIntArray.java
+++ b/src/main/java/fr/univamu/sorting/SortableIntArray.java
@@ -1,48 +1,56 @@
package fr.univamu.sorting;
+import java.util.Arrays;
import java.util.List;
-public class SortableIntArray implements Sortable{
- private final int[] array;
+public class SortableIntArray<T extends Comparable<T>> implements Sortable <T>{
- public SortableIntArray (int [] tab) {
+ private final T[] array;
+
+ public SortableIntArray (T[] tab) {
this.array = tab;
}
public void swap(int index1, int index2){
- int temp = array[index1];
+ T temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
- public int compare (int index1, int index2){
+ @Override
+ public int compare(int index1, int index2) {
+ return array[index1].compareTo(array[index2]);
+ }
+
+/* public int compare (Integer index1, Integer index2){
if (index1 >= index2) {
if (index1 > index2) return 1;
else return 0;
} else {
return -1;
- }
- }
+
+
+ }*/
public int size(){
return array.length;
}
- public int get(int index){
+ public T get(int index){
return array[index];
}
//// a voir avec le prof
@Override
- public List<Integer> getSortableParameter() {
- return null;
+ public List<T> getSortableParameter() {
+ return Arrays.asList(array);
}
@Override
- public void set(int index, int value) {
+ public void set(int index, T value) {
array[index] = value;
}
}
diff --git a/src/main/java/fr/univamu/sorting/SortableIntList.java b/src/main/java/fr/univamu/sorting/SortableIntList.java
index 64dc00d558d58155a7f193172350fe23e4c59e0d..6823139a58666d0fd3e6b6ab866d35c5954b0852 100644
--- a/src/main/java/fr/univamu/sorting/SortableIntList.java
+++ b/src/main/java/fr/univamu/sorting/SortableIntList.java
@@ -2,15 +2,15 @@ package fr.univamu.sorting;
import java.util.List;
-public class SortableIntList implements Sortable {
- private final List<Integer> list;
+public class SortableIntList <T extends Comparable<T>> implements Sortable<T> {
+ private final List<T> list;
- public SortableIntList (List<Integer> lists){
+ public SortableIntList (List<T> lists){
this.list = lists;
}
public void swap (int index1, int index2){
- int temp = list.get(index1);
+ T temp = list.get(index1);
list.set(index1, list.get(index2));
list.set(index2, temp);
}
@@ -19,25 +19,30 @@ public class SortableIntList implements Sortable {
return list.size();
}
- public int get (int index){
+ public T get (int index){
return list.get(index);
}
- public int compare (int index1, int index2){
+ @Override
+ public int compare(int index1, int index2) {
+ return list.get(index1).compareTo(list.get(index2));
+ }
+/*public int compare (T index1, T index2){
if (index1 >= index2) {
if (index1 > index2) return 1;
else return 0;
} else {
return -1;
}
- }
+ //return compare(index1,index2);
+ }*/
- public List<Integer> getSortableParameter() {
+ public List<T> getSortableParameter() {
return list;
}
@Override
- public void set(int index, int value) {
+ public void set(int index, T value) {
list.set(index,value);
}
}
\ No newline at end of file
diff --git a/src/main/java/fr/univamu/sorting/Sorter.java b/src/main/java/fr/univamu/sorting/Sorter.java
index 9412c7dab07019ab358ec9668667271b29ac3381..2249803d48aaeb845b825cf8864a1083782766d2 100644
--- a/src/main/java/fr/univamu/sorting/Sorter.java
+++ b/src/main/java/fr/univamu/sorting/Sorter.java
@@ -1,7 +1,7 @@
package fr.univamu.sorting;
-public interface Sorter {
+public interface Sorter<T extends Comparable<T>> {
void sort();
- Sortable getSortable();
+ Sortable<T> getSortable();
}
diff --git a/src/test/java/fr/univamu/sorting/ListSortTest.java b/src/test/java/fr/univamu/sorting/ListSortTest.java
index a5b6dbfdf24230a9b9792e9eaa812922abb79e1f..0591e40b7709a4d98a1eeaf6ddb920838c21dfbf 100644
--- a/src/test/java/fr/univamu/sorting/ListSortTest.java
+++ b/src/test/java/fr/univamu/sorting/ListSortTest.java
@@ -11,19 +11,25 @@ class ListSortTest {
@Test
- void testSort() {
+ void testQuickSort() {
List<Integer> values = new ArrayList<>(List.of(2,0,28,15,88,1,61));
System.out.println(values);
// List<Integer> values = IntLists.shuffledRange(1,100);
- Sortable sortableValues = new SortableIntList(values);
- QuickSort sorter = new QuickSort(sortableValues);
+ Sortable<Integer> sortableValues = new SortableIntList<>(values);
+ //CountingSortable<Integer> countingSortable = new CountingSortable<>(sortableValues);
+ CountingSortable<Integer> countingSortable = new CountingSortable<>(sortableValues);
+ LoggingSortable<Integer> loggingSortable = new LoggingSortable<>(sortableValues);
+ QuickSort<Integer> sorter = new QuickSort<Integer>(countingSortable);
sorter.sort();
- Sortable sorterSortableValues = sorter.getSortable();
+ Sortable<Integer> sorterSortableValues = sorter.getSortable();
//List<Integer> sortedList = IntStream.rangeClosed(1,100).boxed().toList();
System.out.println(sorterSortableValues.getSortableParameter());
+ System.out.println("nombreSwaps: "+countingSortable.getCountingSwaps());
+ System.out.println("nombreCompare: "+countingSortable.getCountingCompare());
+ System.out.println(loggingSortable.getLogStream());
}
@@ -32,11 +38,11 @@ class ListSortTest {
List<Integer> values = new ArrayList<>(List.of(2,0,28,15,88,1,61));
System.out.println(values);
// List<Integer> values = IntLists.shuffledRange(1,100);
- Sortable sortableValues = new SortableIntList(values);
- InsertionSort sorter = new InsertionSort(sortableValues);
+ Sortable<Integer> sortableValues = new SortableIntList<>(values);
+ InsertionSort<Integer> sorter = new InsertionSort<>(sortableValues);
sorter.sort();
- Sortable sorterSortableValues = sorter.getSortable();
+ Sortable<Integer> sorterSortableValues = sorter.getSortable();
//List<Integer> sortedList = IntStream.rangeClosed(1,100).boxed().toList();