Salut à tous,

Je souhaite faire un algorithme de tri de ma pile plus propre et pour ça, je vais faire le tri fusion.

Dans mon sous-programme " fusion ", quand je mets le sommet_pile(p1) > sommet_pile(p2), ça plante, il me met dès la première itération (la boucle affichée précédemment) qu'il n'y a pas de sommet à p1. Je pense qu'il ne voit pas le sommet de la pile p1 EN COURS (Pourquoi ? Je ne sais pas). Qu'est ce que j'entends par EN COURS ? Voici un schéma qui le résume :https://www.cjoint.com/doc/18_02/HBCvxgqgOxs_image.png

Ce qu'il faudrait, c'est passer d'une pile p1 à une autre pile p1 et pareil pour p2, et ça, je ne vois pas comment faire.

La fonction " tri fusion " qui marche bien normalement :

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
pile tri_fusion(pile p)
{
    printf("\nSOUS PROGRAMME TRI_FUSION\n");
    pile p1 = nouvelle_pile();
    pile p2 = nouvelle_pile();
 
    if(est_elle_vide(p) || un_seul_element(p))
    {
        return p;
    }
 
    diviser(p, &p1, &p2);
 
    p1 = tri_fusion(p1);
 
    p2 = tri_fusion(p2);
 
    printf("------------------------------------------------------AFFICHAGE--------------------------------------------------------\n");
 
    printf("p1 :");
    afficher_pile(p1);
    printf("\n");
 
    printf("p2 :");
    afficher_pile(p2);
    printf("\n");
 
    printf("p :");
    afficher_pile(p);
    printf("\n");
 
    printf("-----------------------------------------------------FIN-AFFICHAGE-----------------------------------------------------\n");
 
    return fusion(p1, p2);
}
La fonction " fusion " avec laquelle je me bagarre :
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
55
56
57
58
59
60
61
62
pile fusion(pile p1, pile p2)
{
    printf("\nSOUS PROGRAMME FUSION\n");
    pile resultat = nouvelle_pile();
    int echange = vrai;
 
    printf("------------------------------------------------------AFFICHAGE--------------------------------------------------------\n");
 
    printf("p1 :");
    afficher_pile(p1);
    printf("\n");
 
    printf("p2 :");
    afficher_pile(p2);
    printf("\n");
 
    printf("-----------------------------------------------------FIN-AFFICHAGE-----------------------------------------------------\n");
 
 
    while(!(est_elle_vide(p1)) || !(est_elle_vide(p2)) && (echange == vrai))
    {
        echange = faux;
 
        if(sommet_pile(p1) > sommet_pile(p2))
        {
            echange = vrai;
 
            resultat = ajouter_pile(resultat, sommet_pile(p1));
            p1 = enlever_element(p1);
            //p2 = enlever_element(p2);
 
        }
 
 
        else
        {
            echange = vrai;
 
            resultat = ajouter_pile(resultat, sommet_pile(p2));
            //resultat = ajouter_pile(resultat, sommet_pile(p1));
 
            //p1 = enlever_element(p1);
            p2 = enlever_element(p2);
 
        }
    }
 
    printf("------------------------------------------------------AFFICHAGE--------------------------------------------------------\n");
 
    printf("resultat :");
    afficher_pile(resultat);
    printf("\n");
 
    printf("-----------------------------------------------------FIN-AFFICHAGE-----------------------------------------------------\n");
 
        return resultat;
 
    // et s'il reste ensuite des éléments dans une pile, terminer le travail
    // puis on note qu'on a mis les éléments dans l'ordre inverse de celui
    // voulu donc il reste encore quelque chose à faire pour les remettre
    // dans l'ordre.
}
Et pour information, les fonctions " echanger_element " et "diviser " qui interviennent mais qui sont justes :

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
////////////////////////////////////////////////
 
void echanger_element(pile *p1, pile *p2)
{
  pile temporaire = *p1;
  *p1 = *p2;
  *p2 = temporaire;
}
 
////////////////////////////////////////////////
 
void diviser(pile p, pile *p1, pile *p2)
{
    while(p)                                    
    {
        *p1 = ajouter_pile(*p1, sommet_pile(p));
        p = enlever_element(p);                 
        echanger_element(p1, p2);               
    }
}
 
////////////////////////////////////////////////