Discussion :

[canary]

Bonsoir à tous,

Je cherche à afficher les temps d'exécution d'un tri rapide et d'un tri par fusion. Cependant, il me retourne toujours 0! c'est plutôt embêtant... pourriez-vous me dépanner svp?


Merci beaucoup!
Aud-(débutante)

[djo.mos]

Bonsoir,
Aggrandis le N: 10 c'est vraiment petit, trop petit !
Refais chaque test n fois, histoire de normaliser.

[canary]

ok alors j'ai simulé pour N=6000

voici les séquences de résultats:
Generating input: 0.015 seconds
Quicksort: 0.0 seconds
MergesortIter: 0.016 seconds
---
Generating input: 0.015 seconds
Quicksort: 0.0 seconds
MergesortIter: 0.0 seconds
---
Generating input: 0.0 seconds
Quicksort: 0.0 seconds
MergesortIter: 0.0 seconds
---
Generating input: 0.0 seconds
Quicksort: 0.016 seconds
MergesortIter: 0.0 seconds
---
Generating input: 0.0 seconds
Quicksort: 0.016 seconds
MergesortIter: 0.0 seconds
---
Generating input: 0.0 seconds
Quicksort: 0.0 seconds
MergesortIter: 0.016 seconds

est-ce normal? je demande ça car je n'ai aucune idée de ce que je devrais obtenir...

Merci à tous
aud-(debutante)

[canary]

quand je simule sur 100000 je me rends compte que dans la majorité des cas, la méthode de tri par fusion prend plus de temps que la méthode tri rapide. est-ce normal?
enfin, est-ce que mon algo de calcul de temps est bien approprié? (est-ce que je calcule n'importe quoi ou bien est-ce la bonne démarche?)

Merci beaucoup à tous pour votre aide
Aud-

[Grimly_old]

Voila ce que j'utilise pour éviter de trop me casser la tête.

2 constructeurs pour éviter d'attendre des années quand la méthode qu'on veux tester est pas si rapide que ça.

J'ai une flemme énorme alors pour gagner du temps sur un échantillons de tests j'ai fait un renvoie de this (regarde le main j'appelle 3 fois ma méthode de tests).

Si tu veux tester qqch, met le dans un runnable et lance le pour voir si ca fait ce que tu veux.

Le comparable est la si tu veux voir qui est le plus rapide . Il te donne en théorie la différence d'exécution entre tes méthodes sur 100000 appels (en ms)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import java.io.PrintStream;
import java.util.ArrayList;
 
public class TimeTest implements Comparable<TimeTest> {
 
	private Runnable runnable;
	private int tests;
	private static final int DEFAULT_TESTS = 100000;
 
	public TimeTest(Runnable runnable) {
		this(runnable, DEFAULT_TESTS);
	}
 
	public TimeTest(Runnable runnable, int tests) {
		this.runnable = runnable;
		this.tests = tests;
	}
 
	@Override
	public int compareTo(TimeTest other) {
		return (int)((this.test()*DEFAULT_TESTS)/this.tests -
					(other.test()*DEFAULT_TESTS)/other.tests);
	}
 
	public TimeTest makeTest() {
		return makeTest(System.out);
	}
 
	public TimeTest makeTest(PrintStream out) {
		out.println("Nouvelle série de tests ...");
		long res = test();
		out.println("Fonctionnement total (pour " + tests + " appels) : " +
				res + " ms.");
		out.println("Fonctionnement unitaire : " + (res/tests) + " ms.");
		return this;
	}
 
	private long test() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < tests; i++)
			runnable.run();
		return System.currentTimeMillis() - start;
	}
 
	public static void main(String[] args) {
		(new TimeTest(new Runnable() {
			public void run() {
				ArrayList<Integer> array = new ArrayList<Integer>(1000);
				for (int i = 0; i < 1000; i++)
					array.add(i);
			}
		})).makeTest().makeTest().makeTest();
	}
}

Les résultats perso de mon main :

Nouvelle série de tests ...
Fonctionnement total (pour 100000 appels) : 3636 ms.
Fonctionnement unitaire : 0 ms.
Nouvelle série de tests ...
Fonctionnement total (pour 100000 appels) : 3543 ms.
Fonctionnement unitaire : 0 ms.
Nouvelle série de tests ...
Fonctionnement total (pour 100000 appels) : 3538 ms.
Fonctionnement unitaire : 0 ms.

Qu'on ne vienne pas dire que ArrayList c'est lent (35ns les 1000 ajouts)