"fin TP3"

.classpath

@@ -7,6 +7,6 @@
 			<attribute name="module" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/TP2/demoTris.java

@@ -1,68 +0,0 @@
-package TP2;
-
-import java.util.Arrays;
-
-public class demoTris {
-
-	int[] tabA = new int[8];
-	tabA[0] = 8;
-	tabA[1] = 4;
-	tabA[2] = 25;
-	tabA[3] = 28;
-	tabA[4] = 13;
-	tabA[5] = 40;
-	tabA[6] = 30;
-	tabA[7] = 23;
-
-	public static void triFusion(int[] numbers) {
-		mergeSort(numbers, 0, numbers.length);
-	}
-	
-	private static void mergeSort(int[] tab, int min, int max) {
-		int mid = 0;
-		if(min != max) {
-			mid = (min+max)/2;
-			
-			mergeSort(tab, min, mid);
-			mergeSort(tab, mid+1, max);
-			
-			int[] tmpTab = new int[max-min+1];
-			int[] t1 = Arrays.copyOfRange(tab, min, mid+1);
-			int[] t2 = Arrays.copyOfRange(tab, mid+1, max);
-			
-			Fusion(t1, t2, tmpTab);
-			
-			for(int i=0; i < max-min; i++) {
-				tab[min+i] = tmpTab[i];
-			}
-		}
-	}
-	
-	private static void Fusion(int[] tab1, int[] tab2, int[] tab) {
-		int i = 0; int i1 = 0; int i2 = 0;
-		
-		while(i1 < tab1.length && i2 < tab2.length) {
-			if(tab1[i1] < tab2[i2]) {
-				tab[i] = tab1[i1];
-				i++;i1++;
-			} else {
-				tab[i] = tab2[i2];
-				i++;i2++;
-			}
-		}
-
-		while(i1<tab1.length) {
-			tab[i] = tab1[i1];
-			i++;i1++;
-		}
-		
-		while(i1<tab2.length) {
-			tab[i] = tab2[i2];
-			i++;i2++;
-		}
-	}
-	
-	public static void main(String[] args) {
-		System.out.println(triFusion(tabA[]));
-	}
-}

src/TP3/Cribble.java

@@ -0,0 +1,24 @@
+package TP3;
+
+public class Cribble {
+	Liste<Integer> l = new Liste<Integer>();
+		
+	public Cribble(int nb) {
+		this.l.remplirListe(nb);
+	}
+	
+	public Liste<Integer> getList() {
+		return this.l;
+	}
+	
+	@Override
+	public String toString() {
+		return this.getList().toString();
+	}
+	
+	public static void main(String[] args) {
+		Cribble c = new Cribble(20);
+		System.out.println(c.toString());
+	}
+	
+}

src/TP3/Liste.java

@@ -0,0 +1,237 @@
+package TP3;
+
+import java.lang.reflect.Array;
+import java.util.Iterator;
+
+
+/**
+ * An empty list is an instance of class {@code Liste} where {@code head=queue=null}.
+ * A list containing one element {@code v} is represented by 2 objects of {@code Liste} where :
+ * <ul> 
+ * <li>{@code v} is stored in {@code head} attribute of first object</li>
+ * <li>queue attribute of first object refers to second {@code Liste} object where head=queue=null.</li>
+ * </ul> 
+ * @author Dr. Denis PALLEZ </br> 
+ * {@link http://denispallez.i3s.unice.fr}
+ * @version 2017-2018
+ */
+
+public class Liste<E> { // 
+	private E tete;
+	private Liste<E> queue;
+	
+	public Liste() {
+		tete = null;
+		queue = null;
+	}
+	public Liste(E n, Liste<E> suivante) {
+		tete=n ;
+		queue = suivante ;
+	}
+	public E getTete() {
+		return tete;
+	}
+	public Liste<E> getQueue() {
+		return queue;
+	}
+	public boolean estVide() {
+		return (tete==null) ;
+	}
+	
+	@Override
+	public String toString() {
+		if (estVide()){
+			return "null";
+		}
+		else {
+			return "("+getTete()+ ", " + getQueue()+")";
+		}
+	}
+	
+	public int taille() {
+		if (estVide())
+			return 0;
+		else
+			return 1 + queue.taille();
+	}
+	public boolean contient(E v) {
+		if(estVide()) {
+			return false;
+		} else if(this.tete == v) {
+			return true;
+		} else {
+			return this.getQueue().contient(v);
+		}
+	}
+	public Liste<E> ajouteTete(E v) {
+		if (this.estVide())
+			return new Liste<E>(v,new Liste<E>()) ;
+		else 
+			return new Liste<E>(v,this.getQueue().ajouteTete(getTete())) ;
+	}
+	
+	public void ajouteTeteProc(E v) {
+		if(this.estVide()) {
+			this.tete = v;
+			this.queue = null;
+		} else {
+			Liste<E> tmp = new Liste<E>(this.getTete(), this.getQueue());
+			this.tete = v;
+			this.queue = tmp;
+		}
+	}
+	
+	public Liste<E> ajouteQueue(E v) {
+		if(this.estVide()) {
+			return new Liste<E>(v, new Liste<E>());
+		} else {
+			return new Liste<E>(this.tete, queue.ajouteQueue(v));
+		}
+	}
+	
+	public Liste<E> suppTete() {
+		if (estVide())
+			return new Liste<E>() ;
+		else if (this.getQueue().estVide())
+			return new Liste<E>() ;
+		else
+			return this.getQueue().getQueue().ajouteTete(getQueue().getTete()) ;
+	}
+	
+	public void ajouteQueueProc(E v) {
+		if (estVide()) {
+			tete = v;
+			queue = new Liste<E>() ;
+		}
+		else
+			queue.ajouteQueueProc(v);
+	}
+	
+	public Liste<E> supprime(E v) {
+		Liste<E> l = new Liste<E>();
+		//TO DO
+		return l;
+	}
+
+	
+	public void suppTeteproc() {
+		//TO DO
+	}
+	
+	public Liste<E> suppQueue() {
+		if(this.estVide()) { //cas vide
+			return new Liste<E>();
+		} else if(this.getQueue().estVide()) {//cas avec un seul élément
+			return new Liste<E>(); 
+		} else { //il faut au moins copier la tête caril y a un autre élément derrière
+			return new Liste<E>(this.getTete(), this.getQueue().suppQueue());
+		}
+	}
+	
+	public void suppQueueProc() {
+		if (estVide()) {}
+		else if (getQueue().estVide()) {
+			tete=null; 
+			queue.finalize();
+			queue=null ;
+		}
+		else getQueue().suppQueueProc(); 
+	}
+	
+	public E get(int pos) {
+		if (estVide())
+			return null ;
+		else if (pos==0) return tete ;
+		else return getQueue().get(pos-1) ; 
+	}
+	
+	public void efface() {
+		//TO DO
+	}
+	
+	public Liste<E> ajouteTous(Liste<E> l) {
+		Liste<E> ll = new Liste<E>();
+		//TO DO
+		return ll;
+	}
+	
+	@SuppressWarnings("unchecked")
+	@Override
+	public boolean equals(Object o) {
+		if (o instanceof Liste<?>) {
+			Liste<E> param = (Liste<E>)(o) ;
+			if (estVide() && param.estVide()) 
+				return true;
+			else if (!estVide() && !param.estVide()) {
+				if (tete.equals(param.tete))
+					return queue.equals(param.queue) ;
+				else return false ;
+			}
+			else return false ;
+		
+		}
+		return false ;
+	}
+	
+	public void supprimeProc(E v) {
+		//TO DO
+	}
+	
+	public Liste<E> supprimeTous(E v) {
+		Liste<E> l = new Liste<E>();
+		//TO DO
+		return l;
+	}
+	
+	public void supprimeTousProc(E v) {
+		//TO DO
+	}
+	
+	public Liste<E> inverse() {
+		Liste<E> l = new Liste<E>();
+		//TO DO
+		return l;
+	}
+
+	public void inverseProc() {
+		//TO DO
+	}
+	
+	public void finalize() {
+		efface() ;
+	}
+	
+	public E[] toArray() {
+		Liste<E> l=this ;
+		@SuppressWarnings("unchecked")
+		E[] array = (E[])Array.newInstance(tete.getClass(),l.taille()) ;
+		int i=0 ;
+		while (!(l.estVide())) {
+			array[i]=l.tete;
+			l=l.queue;
+			i++ ;
+		}
+		return array ;
+	}
+	
+	public Liste<Integer> delMultiple(int n) {
+		if(!this.estVide()) {
+			if((Integer)this.getTete()%n == 0) {
+				return this.getQueue().delMultiple(n);
+			} else {
+				return new Liste<Integer>((Integer)this.getTete(), this.getQueue().delMultiple(n));
+			}
+		} else {
+			return new Liste<Integer>();
+		}
+	}
+	
+	public Liste<Integer> remplirListe(int n) {
+		if(n <= 1) {
+			return new Liste<Integer>();
+		} else {
+			return remplirListe(n-1).ajouteQueue(n);
+		}
+	}
+	
+}

src/TP3/MethodesListes.java

@@ -0,0 +1,5 @@
+package TP3;
+
+public class MethodesListes {
+
+}

tests/TP2/TrisTestEtudiant.java

@@ -73,7 +73,7 @@ public class TrisTestEtudiant {
 	}
 	
 	public static void triRapide(int[] numbers)  {
-		quickSort();
+		//quickSort();
 	}
 	
 	private static void exchange(int[] t, int i, int j) {
@@ -145,6 +145,11 @@ public class TrisTestEtudiant {
 			quickSort(numbers, i, max);
 	}
 	
+	private static int[] partitionnerPivot(int[] numbers, int i, int j, int pivot) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
 	@Before
 	public void setUp() throws Exception {
 	}