liste interclasse(liste l1, liste l2) {
// liste resultat
liste l_result = nouvListe();
// indice courant l1 et l2
int ind1 = 0, ind2 = 0;
int t1 = taille(l1), t2 = taille(l2);
// tq fin d'une des listes non atteinte
while (ind1 < t1 && ind2 < t2) {
if (elt(ind1, l1) < elt(ind2, l2)) {
adjq(elt(ind1, l1), l_result);
++ind1;
} else {
adjq(elt(ind2, l2), l_result);
++ind2;
}
}
// on est arrive a la fin d'une des deux listes, dans la suite, on entre dans un seul while
while (ind1 < t1) {
adjq(elt(ind1, l1), l_result);
++ind1;
}
while (ind2 < t2) {
adjq(elt(ind2, l2), l_result);
++ind2;
}
return l_result;
}
void shell_aux()
{
char * input=(char *)malloc(TAILLE_INPUT*sizeof(char));//Allocation de la chaine de caractère pour gérer la saisi au clavier
int pid_child=0,taille=0;
Liste l=listenouv();//Allocation de la liste
l_handler=l;
input_handler=input;//Mise en place des valeurs des variables globales pour la fin du programme (pour leur désallocation)
int hide=0;//Variable qui vaut 1 si on lance le programme avec '&', 0 sinon
int i=0;//indice du caractère '&'
int status;
char ** arg=NULL;//Pointeur pour un tableau de chaine de caractère
Commande c;
while(1)
{
do
{
printf("> : ");
//Si on envoie un EOF ou on tape "exit" dans le terminal, cela provoque l'appel de la fonction qui arrête le programme
if((fgets(input,TAILLE_INPUT,stdin) == NULL) || estExit(input)) handler(0);//Provoque la désallocation des autres ressources puis la fin du programme
wait_hidden_child(l);//On regarde si un/des processus de la liste de ps caché est mort, et si c'est le cas, on affiche sa notification de décès
}
while(input[0]=='\n');//Demande de saisi tant que l'utilisateur appuie sur Entrée sans indiqué de commande
taille=taille_tableau(input);
input[taille-1]='\0';//On remplace le '\n' en fin de chaine de caractères par un '\0'
i=recherche(input,'&');//On recherche le caractère "&" pour indiqué si oui ou non on doit cacher l'execution du processus
if(i==-1) hide=0;
else
{
hide=1;
input[i]=' ';//Transforme le '&' par un espace
input=elimine_espace_fin(input,taille);
c.commande=malloc((taille+1)*sizeof(char));
strcpy(c.commande,input);//Copie l'intitulé de la commande (tapé au clavier)
}
arg=separation_argument(input);//Sépare les arguments de la commande pour les envoyer à exec plus tard
pid_child=fork();
if(!pid_child)
{
execvp(arg[0],arg);//Lance l'exec de la commande saisi au clavier de la part du fils créer par un fork pour ça
}
else
{
c.pid=pid_child;
if(!hide) waitpid(pid_child,&status,0);//Si on ne doit pas cacher l'execution du processus fils, on fait un waitpid simple sur le pid de ce processus
else
{
adjq(l,c);//Sinon on ajoute la structure commande à la liste des processus cachés
printf("[%d] %d\n",l->taille,pid_child);//Affiche une notification de lancement de processus caché (avec l'ordre d'insertion dans la liste, ainsi que le pid du processus)
}
}
freeArg(arg);//Libère le tableau d'argument
}
return;
}
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);
}
liste concatenation(liste l1, liste l2) {
liste l_result;
l_result = nouvListe();
int i;
// ajout de chaque element de l1
for(i=0; i < taille(l1); ++i) {
adjq(elt(i,l1), l_result);
}
// ajout de chaque element de l2
for(i=0; i < taille(l2); ++i) {
adjq(elt(i,l2), l_result);
}
return l_result;
}
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;
}
