diff --git a/src/main/java/fr/univamu/sorting/Sortable.java b/src/main/java/fr/univamu/sorting/Sortable.java
index e96f6663eb6e7a500dc6b9dcefbfa244840f97d0..1e5865cf28507acfd573bc2598a6e0a5a967f58d 100644
--- a/src/main/java/fr/univamu/sorting/Sortable.java
+++ b/src/main/java/fr/univamu/sorting/Sortable.java
@@ -1,10 +1,19 @@
package fr.univamu.sorting;
+import java.lang.reflect.Array;
import java.util.List;
-public interface Sortable {
- int get(int index);
+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);
+ }
}
diff --git a/src/main/java/fr/univamu/sorting/SortableIntArray.java b/src/main/java/fr/univamu/sorting/SortableIntArray.java
index fa54ebb7cd4e70db071c3b8c5162ef61bf7e11b2..2918e5dae06e4615ce3c6fe6b78f2768dbb297ed 100644
--- a/src/main/java/fr/univamu/sorting/SortableIntArray.java
+++ b/src/main/java/fr/univamu/sorting/SortableIntArray.java
@@ -1,31 +1,31 @@
package fr.univamu.sorting;
-public class SortableIntArray implements Sortable {
- private int[] Array;
+public class SortableIntArray<T extends Comparable<T>> implements Sortable {
+ private T[] Array;
- public SortableIntArray(int [] Array){
+ public SortableIntArray(T[] Array){
this.Array=Array;
}
- public int[] GetArray(){
+ public T[] GetArray(){
return this.Array;
}
public int size(){
return this.Array.length;
}
- public int get(int index){
+ public T get(int index){
return this.Array[index];
}
public void swap(int index1, int index2){
- int a = this.Array[index1];
- int b = this.Array[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]-this.Array[index2];
+ return this.Array[index1].compareTo(this.Array[index1]);
}
}
diff --git a/src/main/java/fr/univamu/sorting/SortableIntList.java b/src/main/java/fr/univamu/sorting/SortableIntList.java
index 0e17a63ef3c54d600e43794375c56b21b442e4d0..0925dbfa72942ad2c8d003f4ea53482f1f265f47 100644
--- a/src/main/java/fr/univamu/sorting/SortableIntList.java
+++ b/src/main/java/fr/univamu/sorting/SortableIntList.java
@@ -1,22 +1,19 @@
package fr.univamu.sorting;
-import java.util.Collection;
-import java.util.Iterator;
import java.util.List;
-import java.util.ListIterator;
-public class SortableIntList implements Sortable {
- private List<Integer> list;
+public class SortableIntList<T extends Comparable<T>> implements Sortable {
+ private List<T> list;
- public SortableIntList(List<Integer> list){
+ public SortableIntList(List<T> list){
this.list = list;
}
- public List<Integer> GetList(){
+ public List<T> GetList(){
return this.list;
}
- public int get(int index){
+ public T get(int index){
return this.list.get(index);
}
@@ -25,13 +22,13 @@ public class SortableIntList implements Sortable {
}
public void swap(int index1, int index2){
- int a = this.list.get(index1);
- int b = this.list.get(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)-this.list.get(index2);
+ return this.list.get(index1).compareTo(this.list.get(index2));
}
}
diff --git a/src/main/java/fr/univamu/sorting/Sorter.java b/src/main/java/fr/univamu/sorting/Sorter.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6016a5f26a6a22d4bb7dc04c9e239477f4aabf8
--- /dev/null
+++ b/src/main/java/fr/univamu/sorting/Sorter.java
@@ -0,0 +1,5 @@
+package fr.univamu.sorting;
+
+public interface Sorter<T extends Comparable<T>> {
+ void sort();
+}
diff --git a/src/main/java/fr/univamu/sorting/insertionSort.java b/src/main/java/fr/univamu/sorting/insertionSort.java
index 4e5a15c4bbf26cd3927a27fa79e7df4269f6d117..65a5ed110359baef9e7b203417064a0e7a0b76f8 100644
--- a/src/main/java/fr/univamu/sorting/insertionSort.java
+++ b/src/main/java/fr/univamu/sorting/insertionSort.java
@@ -1,6 +1,6 @@
package fr.univamu.sorting;
-public class insertionSort {
+public class insertionSort<T extends Comparable<T>> implements Sorter {
private Sortable Mustsort;
public insertionSort(Sortable Mustsort){
@@ -12,9 +12,16 @@ public class insertionSort {
}
public void sort() {
int i = 0;
- while (i<Mustsort.size()-1){
- int x = Mustsort.get(i);
-
+ 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);
}
}
}
diff --git a/src/main/java/fr/univamu/sorting/quicksortSort.java b/src/main/java/fr/univamu/sorting/quicksortSort.java
index 911edab707a8ca11bd91a5d6004f5db3f57ac1d9..cb66a48a9cec7152325a333f0b0932e9a2def8c7 100644
--- a/src/main/java/fr/univamu/sorting/quicksortSort.java
+++ b/src/main/java/fr/univamu/sorting/quicksortSort.java
@@ -2,7 +2,7 @@ package fr.univamu.sorting;
import java.util.List;
-public class quicksortSort {
+public class quicksortSort<T extends Comparable<T>> implements Sorter {
private Sortable Mustsort;
public quicksortSort(Sortable Mustsort){
@@ -13,28 +13,28 @@ public class quicksortSort {
return this.Mustsort;
}
- private List<List<Integer>> split(List<Integer> Tosplit){
- int a = Tosplit.get(Tosplit.size()-1);
- List<Integer> A = List.of();
- List<Integer> B = List.of();
- List<Integer> C = List.of();
- for(int b : Tosplit){
- if (a>b){
+ 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==b){
+ if (a.compareTo(b)==0){
C.add(b);
}
- if (a<b){
+ if (a.compareTo(b)<0){
B.add(b);
}
}
return List.of(A,C,B);
}
- private boolean HasRightSize(List<List<Integer>> Tocheck){
+ private boolean HasRightSize(List<List<T>> Tocheck){
boolean Truth = true;
- for (List<Integer> L : Tocheck){
+ for (List<T> L : Tocheck){
if (L.size()>1){
Truth = false;
}
@@ -42,17 +42,17 @@ public class quicksortSort {
return Truth;
}
- private List<Integer> Tolist(Sortable S){
+ private List<T> Tolist(Sortable S){
int A = 0;
- List<Integer> list = List.of();
+ List<T> list = List.of();
while (A<S.size()){
- list.add(S.get(A));
+ list.add((T) S.get(A));
A=A+1;
}
return list;
}
- private void Change(List<Integer> list){
+ private void Change(List<T> list){
int A = 0;
while (A<list.size()){
int B = 0;
@@ -66,19 +66,19 @@ public class quicksortSort {
}
}
public void sort() {
- List<Integer> Tosort = Tolist(this.Mustsort);
- List<List<Integer>> Part = List.of(Tosort);
+ List<T> Tosort = Tolist(this.Mustsort);
+ List<List<T>> Part = List.of(Tosort);
boolean Issort = false;
while (Issort == false){
- List<List<Integer>> Provpart = List.of();
- for (List<Integer> L : Part){
+ List<List<T>> Provpart = List.of();
+ for (List<T> L : Part){
Provpart.addAll(split(L));
}
Part=Provpart;
Issort=HasRightSize(Part);
}
- List<Integer> sort=List.of();
- for (List<Integer> L : Part){
+ List<T> sort=List.of();
+ for (List<T> L : Part){
sort.addAll(L);
}
Change(sort);