ffff

.idea/gradle.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>

.idea/misc.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_20" project-jdk-name="20" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_20" default="true" project-jdk-name="20" project-jdk-type="JavaSDK" />
 </project>
\ No newline at end of file

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

@@ -6,7 +6,17 @@ import java.util.stream.Collectors;
 public class App {
 
   public static void main(String[] args) {
-    List<Integer> shuffled = IntLists.shuffledRange(0,1000);
+
+    List<Integer> shuffled = IntLists.shuffledRange(0,10);
+    Sortable<Integer> a = new SortableIntList<>(shuffled);
+ //   CountingSortable<Integer> Shuffled = new CountingSortable<>(a);
+    //CountingSortable<Integer> toSort = new CountingSortable<>(Shuffled);
+    Sorter Sort = new QuickSort<Integer>(a);
+    Sort.sort();
+    System.out.println(Sort);
+
+
+
     System.out.println(
         shuffled.stream()
         .map(String::valueOf)

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

@@ -2,45 +2,52 @@ package fr.univamu.sorting;
 
 import java.util.List;
 
-public class CountingSortable<T extends Comparable<T>> extends SortableDecorator<T> {
+public class CountingSortable<T extends Comparable<T>> /* extends SortableDecorator<T> */ implements Sortable<T>{
+    private Sortable<T> sortable;
 
-    private  Sortable<T> values;
-    public static int countingSwaps = 0;
-    public static int countingCompare = 0;
+    @Override
+    public void swap(int index1, int index2) {
 
-    public CountingSortable( Sortable<T> values) {
-        super(values);
     }
 
+    @Override
+    public int compare(int index1, int index2) {
+        return 0;
+    }
 
+    @Override
     public int size() {
-        return super.size();
+        return 0;
     }
 
+    @Override
     public T get(int index) {
-       return super.get(index);
+        return null;
     }
 
-
-    public void swap (int index1, int index2){
-        countingSwaps++;
-        super.swap(index1,index2);
+    @Override
+    public void set(int index, T value) {
 
     }
 
-    public int compare (int index1, int index2){
-        countingCompare ++;
-        return super.compare(index1,index2);
+    public int countingSwaps = 0;
+    public int countingCompare = 0;
 
+    public CountingSortable(Sortable<T> values) {
+        this.sortable = values;
     }
 
 
-    public void set(int index, T value) {
-        super.set(index, value);
+
+    public void swapAction (int index1, int index2){
+        countingSwaps++;
+        sortable.swap(index1,index2);
+
     }
 
-    public List<T> getSortableParameter() {
-        return super.getSortableParameter();
+    public void compareAction(int index1, int index2){
+        countingCompare ++;
+        sortable.compare(index1, index2);
     }
 
     public int getCountingCompare() {

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

 package fr.univamu.sorting;
 
-public class InsertionSort<T extends Comparable<T>> implements Sorter<T>{
+public class InsertionSort<T extends Comparable<T>> implements Sorter{
     private final Sortable<T> sortable;
     public InsertionSort( Sortable<T> sortable){
         this.sortable = sortable;
@@ -22,8 +22,5 @@ public class InsertionSort<T extends Comparable<T>> implements Sorter<T>{
     }
 
 
-    public Sortable<T> getSortable (){
-        return sortable;
-    }
 
 }

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

@@ -5,7 +5,7 @@ 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){
@@ -14,37 +14,16 @@ public class LoggingSortable<T extends Comparable<T>> extends SortableDecorator<
 
 
     @Override
-    public void swap(int index1, int index2) {
-        super.swap(index1, index2);
+    public void swapAction(int index1, int index2) {
         logStream.println("swap : "+index1+" et "+index2);
     }
 
     @Override
-    public int compare(int index1, int index2) {
+    public void compareAction (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,49 +2,43 @@ package fr.univamu.sorting;
 
 
 
-public class QuickSort<T extends Comparable<T>> implements Sorter<T> {
+public class QuickSort<T extends Comparable<T>> implements Sorter {
     private final Sortable<T> sortable;
 
     public QuickSort(Sortable<T> sortable) {
         this.sortable = sortable;
     }
 
-    private int partition(int start , int end) {
+    private void partition(int start , int end) {
         //T pivot = sortable.get(end);
-        int i = start - 1;
-
-        for (int j = start; j < end; j++) {
-            int bool = sortable.compare(j,end);
-            if (bool <= 0){
+        if (end <= start) {
+            return;
+        }
+        int i = start + 1;
+        int j = end;
+        while (i < j) {
+            while (i <= j && sortable.compare(start,i) > 0) {
                 i++;
-                sortable.swap(i, j);
             }
+            while (i <= j && sortable.compare(start,j) < 0) {
+                j--;
             }
-
-        sortable.swap(i + 1, end);
-        return i + 1;
+            if (i >= j) { break; }
+            sortable.swap(i,j);
+            i++;
+            j--;
+        }
+        sortable.swap(start,i-1);
+        partition(start,i-1);
+        partition(i+1,end);
     }
 
 
     public void sort() {
-        if (sortable == null || sortable.size() <= 1) {
-            return;
-        }
-        sort(0, sortable.size() - 1);
-    }
-
-    private void sort(int start, int end) {
-        if (start < end) {
-            int pivotIndex = partition(start, end);
-            sort(start, pivotIndex - 1);
-            sort(pivotIndex + 1, end);
-        }
+      partition(0, sortable.size()-1);
     }
 
 
-    public Sortable<T> getSortable (){
-        return sortable;
-    }
 
 
 }

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

@@ -13,7 +13,6 @@ public interface Sortable<T extends Comparable<T>> {
 
     void  set(int index,T value);
 
-    List<T> getSortableParameter();
 
 
 }

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

@@ -24,19 +24,18 @@ public abstract class SortableDecorator<T extends Comparable<T>> implements Sort
         values.set(index,value);
     }
 
-    @Override
-    public List<T> getSortableParameter() {
-        return values.getSortableParameter();
-    }
-
     @Override
     public int compare(int index1, int index2) {
+        this.compareAction(index1,index2);
         return values.compare(index1,index1);
     }
 
+    protected abstract void compareAction(int index1, int index2);
+
     @Override
     public void swap(int index1, int index2) {
         values.swap(index1,index2);
     }
+    protected abstract void swapAction (int index1, int index2);
 }
 

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

@@ -43,11 +43,6 @@ public class SortableIntArray<T extends Comparable<T>> implements Sortable <T>{
         return array[index];
     }
 
-    //// a voir avec le prof
-    @Override
-    public List<T> getSortableParameter() {
-        return Arrays.asList(array);
-    }
 
     @Override
     public void set(int index, T value) {

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

@@ -37,9 +37,6 @@ public class SortableIntList <T extends Comparable<T>> implements Sortable<T> {
         //return compare(index1,index2);
     }*/
 
-    public List<T> getSortableParameter() {
-        return list;
-    }
 
     @Override
     public void set(int index, T value) {

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

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

src/test/java/fr/univamu/sorting/ListSortTest.java

@@ -11,43 +11,7 @@ class ListSortTest {
 
 
   @Test
-  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<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<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());
+  void testSort() {
 
   }
-
-@Test
-  void testInsertionSort() {
-    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<Integer> sortableValues = new SortableIntList<>(values);
-    InsertionSort<Integer> sorter = new InsertionSort<>(sortableValues);
-    sorter.sort();
-
-    Sortable<Integer> sorterSortableValues = sorter.getSortable();
-
-    //List<Integer> sortedList = IntStream.rangeClosed(1,100).boxed().toList();
-
-    System.out.println(sorterSortableValues.getSortableParameter());
-
-  }
-
 }
\ No newline at end of file