int main() {
int i;
clock_t start_1;
clock_t end_1;
clock_t start_2;
clock_t end_2;
liste l1 = nouvListe();
liste l2 = nouvListe();
start_1 = clock();
srand(time(NULL)); // initialisation de la suite aleatoire
for(i=0; i < 10000; ++i) {
adjt(rand()%100, l1);
}
end_1 = clock();
double time1 = (double)(end_1-start_1)/CLOCKS_PER_SEC;
//printf("res : %f", res);
start_2 = clock();
for(i=0; i < 10001; ++i) {
adjq(rand()%100, l2);
}
end_2 = clock();
double time2 = (double)(end_2-start_2)/CLOCKS_PER_SEC;
printf("Debut : %f, Fin : %f, res = %f \n", time1, time2, time2-time1);
}
/* version iterative */
liste renverse_iter(liste l) {
liste l_result = nouvListe();
int i=0, fin = taille(l);
while(i < fin) {
adjt(elt(i, l), l_result);
++i;
}
return l_result;
}
Liste Exemple1()
{
Liste l=listenouv();
l=adjt(l,11);
l=adjt(l,4);
l=adjt(l,10);
l=adjt(l,1);
l=adjt(l,9);
l=adjt(l,3);
l=adjt(l,8);
return l;
}
Liste al(Arbin a)//Parcours infixe inverse : d r g
{
Liste l=listenouv();
Listea tmp=listenouv_a();
Arbin atmp;
tmp=desd(a,tmp);
while(tailleliste_a(tmp)>0)
{
atmp=tete_a(tmp);
tmp=supt_a(tmp);
l=adjt(l,rac(atmp));
tmp=desd(ag(atmp),tmp);
}
freeListe_a(tmp);
return l;
}
Liste Exemple2()
{
Liste l=listenouv();
l=adjt(l,7);
l=adjt(l,14);
l=adjt(l,2);
l=adjt(l,13);
l=adjt(l,5);
l=adjt(l,15);
return l;
}
int main() {
int i;
liste li = nouvListe(), li2 = nouvListe();
adjt(1, li);
adjt(5, li);
adjt(-7, li);
printf ("liste : "); affiche(li);
printf("taille : %d\n", taille(li));
printf("vide ? : %s\n", (estVide(li)?"oui":"non"));
for(i=1; i <= 10; ++i) {
adjq(i*i, li2);
}
printf ("liste : "); affiche(li2);
printf("tete : %d queue : %d\n", tete(li2), queue(li2));
printf("====== suppressions =========\n");
supt(li2);
printf ("apres supt : "); affiche(li2);
supq(li2);
printf ("apres supq : "); affiche(li2);
// creation de deux listes avec des elements choisis au hasard
printf("====== tris et renversement =========\n");
srand(time(NULL)); // initialisation de la suite aleatoire
printf("liste 11 : ");
liste l1 = nouvListe();
for(i=0; i < 15; ++i) {
adjt(rand()%30, l1);
}
affiche (l1);
printf("liste 12 : ");
liste l2 = nouvListe();
for(i=0; i < 10; ++i) {
adjt(rand()%30, l2);
}
affiche (l2);
liste l1t = trie(l1);
liste l2t = trie(l2);
printf("liste 11 apres trie : "); affiche(l1t);
printf("liste 12 apres trie : "); affiche(l2t);
liste l3t = interclasse(l1t,l2t);
printf("interclassement : "); affiche(l3t);
printf("renversement iter : "); affiche(renverse_iter(l3t));
printf("renversement recur : "); affiche(renverse_recur(l3t));
printf("====== palindrome =========\n");
liste lpalin = nouvListe();
adjt(1, lpalin);
adjt(2, lpalin); adjq(2, lpalin);
adjt(8, lpalin); adjq(8, lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
supt(lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
return 0;
}
/* fonction auxiliaire */
void renverse_cur(liste l, liste l_result, int ind) {
if (ind == taille(l)) return;
adjt(elt(ind, l), l_result);
renverse_cur(l, l_result, ind+1);
return;
}
