FIN 2e partie

src/main/java/fr/univamu/sorting/CountingSortable.java

+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;
+    }
+}

src/main/java/fr/univamu/sorting/InsertionSort.java

 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;
     }
 

src/main/java/fr/univamu/sorting/LoggingSortable.java

+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;
+    }
+}

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;
     }
 

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 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();
 
 
 }

src/main/java/fr/univamu/sorting/SortableDecorator.java

+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);
+    }
+}
+

src/main/java/fr/univamu/sorting/SortableIntArray.java

 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;
     }
 
+    @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;
     }
 }

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);
     }
 
+    @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

src/main/java/fr/univamu/sorting/Sorter.java

 package fr.univamu.sorting;
 
-public interface Sorter {
+public interface Sorter<T extends Comparable<T>> {
 
     void sort();
-    Sortable getSortable();
+    Sortable<T> getSortable();
 }

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();