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

@@ -12,6 +12,7 @@ public class App {
         .map(String::valueOf)
         .collect(Collectors.joining(",","[","]"))
     );
+
     System.exit(0);
   }
 }

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

+package fr.univamu.sorting;
+
+import java.lang.reflect.Array;
+import java.util.List;
+
+public interface Sortable<T extends Comparable<T>> {
+    T get(int index);
+    int size();
+    void swap(int index1, int index2);
+    int compare(int index1, int index2);
+
+    static <T extends Comparable<T>> Sortable of(List<T> A) {
+        return new SortableIntList(A);
+    }
+
+    static <T extends Comparable<T>> Sortable of(T[] A) {
+        return new SortableIntArray(A);
+    }
+}

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

+package fr.univamu.sorting;
+
+public class SortableIntArray<T extends Comparable<T>> implements Sortable {
+    private T[] Array;
+
+    public SortableIntArray(T[] Array){
+        this.Array=Array;
+    }
+
+    public T[] GetArray(){
+        return this.Array;
+    }
+
+    public int size(){
+        return this.Array.length;
+    }
+    public T get(int index){
+        return this.Array[index];
+    }
+    public void swap(int index1, int index2){
+        T a = this.Array[index1];
+        T b = this.Array[index2];
+        this.Array[index1] = b;
+        this.Array[index2] = a;
+    }
+
+    public int compare(int index1, int index2){
+        return this.Array[index1].compareTo(this.Array[index1]);
+    }
+
+}

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

+package fr.univamu.sorting;
+
+import java.util.List;
+
+public class SortableIntList<T extends Comparable<T>> implements Sortable {
+    private List<T> list;
+
+    public SortableIntList(List<T> list){
+        this.list = list;
+    }
+
+    public List<T> GetList(){
+        return this.list;
+    }
+
+    public T get(int index){
+        return this.list.get(index);
+    }
+
+    public int size(){
+        return this.list.size();
+    }
+
+    public void swap(int index1, int index2){
+        T a = this.list.get(index1);
+        T b = this.list.get(index2);
+        this.list.add(index2,a);
+        this.list.add(index1,b);
+    }
+
+    public int compare(int index1, int index2){
+        return this.list.get(index1).compareTo(this.list.get(index2));
+    }
+}

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

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

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

+package fr.univamu.sorting;
+
+public class insertionSort<T extends Comparable<T>> implements Sorter {
+    private Sortable Mustsort;
+
+    public insertionSort(Sortable Mustsort){
+        this.Mustsort = Mustsort;
+    }
+
+    public Sortable GetSortable(){
+        return this.Mustsort;
+    }
+    public void sort() {
+        int i = 0;
+        while (i<this.Mustsort.size()-1){
+            T x = (T) this.Mustsort.get(i);
+            int j = i;
+            while (j>0){
+                while (x.compareTo((T)this.Mustsort.get(j-this.Mustsort.size()))<0){
+                    this.Mustsort.swap(j,j-this.Mustsort.size());
+                    j=j-this.Mustsort.size();
+                }
+            }
+            this.Mustsort.swap(j,i);
+        }
+    }
+}

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

+package fr.univamu.sorting;
+
+import java.util.List;
+
+public class quicksortSort<T extends Comparable<T>> implements Sorter {
+    private Sortable Mustsort;
+
+    public quicksortSort(Sortable Mustsort){
+        this.Mustsort = Mustsort;
+    }
+
+    public Sortable GetSortable(){
+        return this.Mustsort;
+    }
+
+    private List<List<T>> split(List<T> Tosplit){
+        T a = Tosplit.get(Tosplit.size()-1);
+        List<T> A = List.of();
+        List<T> B = List.of();
+        List<T> C = List.of();
+        for(T b : Tosplit){
+            if (a.compareTo(b)>0){
+                A.add(b);
+            }
+            if (a.compareTo(b)==0){
+                C.add(b);
+            }
+            if (a.compareTo(b)<0){
+                B.add(b);
+            }
+        }
+        return List.of(A,C,B);
+    }
+
+    private boolean HasRightSize(List<List<T>> Tocheck){
+        boolean Truth = true;
+        for (List<T> L : Tocheck){
+            if (L.size()>1){
+                Truth = false;
+            }
+        }
+        return Truth;
+    }
+
+    private List<T> Tolist(Sortable S){
+        int A = 0;
+        List<T> list = List.of();
+        while (A<S.size()){
+            list.add((T) S.get(A));
+            A=A+1;
+        }
+        return list;
+    }
+
+    private void Change(List<T> list){
+        int A = 0;
+        while (A<list.size()){
+            int B = 0;
+            while (B<this.Mustsort.size()){
+                if (this.Mustsort.get(B) == list.get(A)){
+                    this.Mustsort.swap(B, A);
+                    B=B+1;
+                }
+            }
+            A=A+1;
+        }
+    }
+    public void sort() {
+        List<T> Tosort = Tolist(this.Mustsort);
+        List<List<T>> Part = List.of(Tosort);
+        boolean Issort = false;
+        while (Issort == false){
+            List<List<T>> Provpart = List.of();
+            for (List<T> L : Part){
+                Provpart.addAll(split(L));
+            }
+            Part=Provpart;
+            Issort=HasRightSize(Part);
+        }
+        List<T> sort=List.of();
+        for (List<T> L : Part){
+            sort.addAll(L);
+        }
+        Change(sort);
+    }
+}