From cd79f547c7bb04379c7b46ea129175d412f33891 Mon Sep 17 00:00:00 2001
From: Rochas <thibaut.rochas@etudiant.univ-rennes1.fr>
Date: Fri, 19 Dec 2025 20:33:44 +0100
Subject: [PATCH] Sorting Test + Impl

---
 .../src/main/java/fr/istic/vv/Sorting.java    | 123 +++++++++++++-
 .../test/java/fr/istic/vv/SortingTest.java    | 151 +++++++++++++++++-
 .../target/classes/fr/istic/vv/Sorting.class  | Bin 851 -> 3890 bytes
 .../fr/istic/vv/SortingTest.class             | Bin 630 -> 6458 bytes
 4 files changed, 268 insertions(+), 6 deletions(-)

diff --git a/code/sorting/src/main/java/fr/istic/vv/Sorting.java b/code/sorting/src/main/java/fr/istic/vv/Sorting.java
index 05a525c..343fad4 100644
--- a/code/sorting/src/main/java/fr/istic/vv/Sorting.java
+++ b/code/sorting/src/main/java/fr/istic/vv/Sorting.java
@@ -1,12 +1,129 @@
 package fr.istic.vv;
+import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.List;
 
 public class Sorting {
 
-    public static <T>  T[] bubblesort(T[] array, Comparator<T> comparator) { return null; }
+    public static <T> void swap(T[] array, int i, int j){
+        T temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+
+    // BUBBLESORT ///////////////////////////////////////////////////////////////////////
+
+    public static <T>  T[] bubblesort(T[] array, Comparator<T> comparator) {
+        int n = array.length;
+        T[] sortedArray=array.clone();
+        boolean swapped = true;
+        while(swapped){
+            swapped = false;
+            for(int i = 0; i<n-1; i++){
+                if(comparator.compare(sortedArray[i], sortedArray[i+1])>0){
+                    swap(sortedArray, i, i+1);
+                    swapped = true;
+                }
+            }
+            n=n-1;
+        }
+        for(int i = 0; i<sortedArray.length; i++){
+            //System.out.print( sortedArray[i] + " ");
+        }
+         //System.out.println("");
+        return sortedArray;
+    }
+
+    // QUICKSORT ///////////////////////////////////////////////////////////////////////
+
+    public static <T> T[] quicksort(T[] array, Comparator<T> comparator)  {
+        T[] sortedArray=array.clone();
+
+        quicksortBis(sortedArray, comparator, 0, sortedArray.length-1);
+
+        return sortedArray;
+    }
+
+    private static <T> void quicksortBis(T[] array, Comparator<T> comparator, int first, int last){
+        if(first<last){
+            int pivot = (last-first)/2;
+            pivot = partition(array,comparator,first,last,pivot);
+            quicksortBis(array, comparator,first, pivot-1);
+            quicksortBis(array, comparator,pivot+1, last);
+        }
+    }
+
+    private static <T> int partition(T[] array, Comparator<T> comparator, int first, int last,int pivot){
+        swap(array, first, last);
+        int j = first;
+        for(int i = first; i<last; i++){
+            if(comparator.compare(array[i], array[last])<=0){
+                swap(array, i, j);
+                j++;
+            }
+        }
+        swap(array, last, j);
+        return j;
+    }
+
+    // MERGESORT ///////////////////////////////////////////////////////////////////////
+
+    public static <T> T[] mergesort(T[] array, Comparator<T> comparator) {
+        List<T> list = new ArrayList<T>();
+
+        for(int i = 0; i<array.length; i++){
+            list.add(array[i]);
+        }
+
+        list = mergesortBis(list,comparator);
+        
+        T[] sortedArray=array.clone();
+        for(int i = 0; i<array.length; i++){
+           sortedArray[i] = list.get(i);
+        }
+
+        return sortedArray;
+    }
+
+    public static <T> List<T> mergesortBis(List<T> list, Comparator<T> comparator) {
+        List<T> res = list;
+
+        if(list.size()>1){
+            List<T> list1 = new ArrayList<T>(list.subList(0,list.size()/2));
+            List<T> list2 = new ArrayList<T>(list.subList(list.size()/2,list.size()));
+            
+            res = merge(mergesortBis(list1,comparator),mergesortBis(list2,comparator),comparator);
+        }
+
+        return res;
+    }
+
+    public static <T> List<T> merge(List<T> list1, List<T> list2, Comparator<T> comparator){
+        List<T> res = new ArrayList<T>();
+        int i = 0;
+        int j = 0;
+        while(i<list1.size() || j<list2.size()){
+            if(j>=list2.size()) {
+                res.add(list1.get(i));
+                i++;
+            }
+            else if(i>=list1.size()) {
+                res.add(list2.get(j));
+                j++;
+            }
+            else if(comparator.compare(list1.get(i),list2.get(j))<=0){
+                res.add(list1.get(i));
+                i++;
+            }
+            else{
+                res.add(list2.get(j));
+                j++;
+            }
+        }
+        return res;
+    }
+
 
-    public static <T> T[] quicksort(T[] array, Comparator<T> comparator)  { return null; }
 
-    public static <T> T[] mergesort(T[] array, Comparator<T> comparator) { return null; }
 
 }
diff --git a/code/sorting/src/test/java/fr/istic/vv/SortingTest.java b/code/sorting/src/test/java/fr/istic/vv/SortingTest.java
index c276c96..80d6c96 100644
--- a/code/sorting/src/test/java/fr/istic/vv/SortingTest.java
+++ b/code/sorting/src/test/java/fr/istic/vv/SortingTest.java
@@ -1,9 +1,154 @@
 package fr.istic.vv;
 import net.jqwik.api.*;
+import static fr.istic.vv.Sorting.*;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
 
 public class SortingTest {
-    @Property
-    boolean absoluteValueOfAllNumbersIsPositive(@ForAll int anInteger) {
-        return Math.abs(anInteger) >= 0;
+
+    public static <T> boolean isSorted(T[] array, Comparator<T> comparator){
+        boolean isSorted = true;
+        for(int i = 0; i<array.length-1 && isSorted; i++){
+            isSorted = isSorted && comparator.compare(array[i],array[i+1])<=0;
+        }
+        return isSorted;
     }
+
+    public static <T> Map<T,Integer> countNbElement(T[] array){
+        Map<T,Integer> map = new HashMap<T,Integer>();
+            for(int i = 0; i<array.length; i++){
+                if(map.containsKey(array[i])){
+                    int newVal = map.get(array[i])+1;
+                    map.put(array[i],newVal);
+                }
+                else{
+                    map.put(array[i],1);
+                }
+            }
+        return map;
+    }
+
+    public static <T> boolean haveSameElements(T[] array1,T[] array2){
+        boolean isSorted = array1.length==array2.length;
+        if(isSorted){
+            Map<T,Integer> elements1 = countNbElement(array1);
+            Map<T,Integer> elements2 = countNbElement(array2);
+            for (T key : elements1.keySet()) {
+                isSorted = isSorted && elements2.containsKey(key) && elements1.get(key) == elements2.get(key);
+                if(!isSorted)  break;
+            }
+        }
+        return isSorted;
+    }
+
+    public static <T> void displayerCompare(T[] array1, T[] array2){
+        for(int i = 0; i<array1.length; i++){
+            System.out.print(array1[i] + " ");
+        }
+        System.out.println("");
+        for(int i = 0; i<array2.length; i++){
+            System.out.print(array2[i] + " ");
+        }
+        System.out.println("\n");
+    }
+
+
+    static Comparator<Integer> comparatorInt = (a, b) -> a-b; //-1 0 1 2 3
+    static Comparator<String> comparatorStr = (a, b) -> a.compareTo(b); //a ab ac b c d
+
+
+
+    // BUBBLESORT ///////////////////////////////////////////////////////////////////////
+
+    @Property
+    void arrayIsSortedBubble(@ForAll Integer[] array) {
+        Integer[] sortedArray = bubblesort(array, comparatorInt);
+
+        boolean res = isSorted(sortedArray,comparatorInt);
+
+        if(!res){
+            System.out.println("\nisSorted Bubble Fail :\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+
+    @Property
+    void sameElementsBubble(@ForAll Integer[] array) {
+        Integer[] sortedArray = bubblesort(array, comparatorInt);
+
+        boolean res = haveSameElements(array,sortedArray);
+
+        if(!res){
+            System.out.println("\nisSame Bubble Fail:\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+
+
+    // QUICKSORT ///////////////////////////////////////////////////////////////////////
+
+    @Property
+    void arrayIsSortedQuick(@ForAll Integer[] array) {
+        Integer[] sortedArray = quicksort(array, comparatorInt);
+
+        boolean res = isSorted(sortedArray,comparatorInt);
+
+        if(!res){
+            System.out.println("\nisSorted Quick Fail :\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+
+    @Property
+    void sameElementsQuick(@ForAll Integer[] array) {
+        Integer[] sortedArray = quicksort(array, comparatorInt);
+
+        boolean res = haveSameElements(array,sortedArray);
+
+        if(!res){
+            System.out.println("\nisSame Quick Fail:\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+
+    // MERGESORT ///////////////////////////////////////////////////////////////////////
+
+    @Property
+    void arrayIsSortedMerge(@ForAll Integer[] array) {
+        Integer[] sortedArray = mergesort(array, comparatorInt);
+
+        boolean res = isSorted(sortedArray,comparatorInt);
+
+        if(!res){
+            System.out.println("\nisSorted Merge Fail :\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+
+    @Property
+    void sameElementsMerge(@ForAll Integer[] array) {
+        Integer[] sortedArray = mergesort(array, comparatorInt);
+
+        boolean res = haveSameElements(array,sortedArray);
+
+        if(!res){
+            System.out.println("\nisSame Merge Fail:\n");
+            displayerCompare(array,sortedArray);
+        }
+
+        assert res;
+    }
+    
 }
\ No newline at end of file
diff --git a/code/sorting/target/classes/fr/istic/vv/Sorting.class b/code/sorting/target/classes/fr/istic/vv/Sorting.class
index beb6ca41c552085dd6015613c6fa757c7ce3a92e..66ecef93373fc0f7c2507cb4174550a56a76d42d 100644
GIT binary patch
literal 3890
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

literal 851
zcmb7B%TB^T6g>mw(Tai~_`r=jabcGxmari)E*f3XuyHl5wGKjyLrcP6>B_`~AK*tB
z?@%;8x?yvlXU@HI?)%5<8-Oz$mXKp;+(}c+V&R$dxjBerEW)4!jiEN;b8e1#7?{`Y
z$oFD~VpoJB?lI(#J3|JoAKm%}^3W?NpvX|QMd)886W5mxcgH?M-Htpy9&#yEzA9?*
zy_hjH?TpbDgW)DFfoHS}L+|*;{=0~kR+3nZ&3-hQa>?UJTAd6egFX;J$m2xPHdfa;
z|IbDv94DKzON|~8lVd1wDfxmF%ba6)-<vSBvNu$XUwSO2Uz)TtU!?Qt6OW1T9#Td0
zi7$hdI>sPMq~~7<rFCU>y;G$ZjzDLkI|CX;bRM!L%1rW%eBtB;<!1_VFvzO5f^Lwl
zqyX}pl<C+)l~6T`bJ$*zToNLua`r?v|AV2pWN4*b)X|{6dbfiny=hULva8B2RdnpF
U!CqdQeSZyhV@-C3gXQ1apAnj&Q~&?~

diff --git a/code/sorting/target/test-classes/fr/istic/vv/SortingTest.class b/code/sorting/target/test-classes/fr/istic/vv/SortingTest.class
index aaa1fa5aa2ae38fb135811cc49b243af4562b580..94bc923b8c5291fa3875ac42accf787ffb232aae 100644
GIT binary patch
literal 6458
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

delta 377
zcmYLDyG{a86r9WMvak#I#s~Nc4M;&^Vr-0wp>Ye;L_=YB(JQX5i(wZm{QxVorST7F
ztTYsUfInhkZ)u!`M2mA~CTC{u9d3T>*2mBA9l$nLAFZuoa>w=Ea92PpSDFHPy>qTC
zXh>&ZM9-oceTh=FBwInp>xHT*y`DO}*z>%D-c3t&11C7@1a9c|6|-fhavD9P?wmQy
zo5%~~u4G@<Jn6S<4H;f$uz*Fr#I~{95lBnl@k7;CT>(LzJr3pBbwl2s$d;#~PkZei
z>tKjq1`=cjlH4X$jVOr5#w$`UqqD^wp8*{<cV=uLW~qQ2CRjB|7Q3d1(;PGInTZK!
rpFBad3vZZxf>GB8+JIWaf4Mm-&yRh7<u;a3V7fSRi!|vnX#y+1EZRAm