Algorithme vers C

S'il vous plaît, je veux la transformation d'un algorithme vers langage C
Soient
List_triangle Une Liste De Liste ( Entier , Entier ) ;
List_trie Une Liste De Liste ( Entier , Entier ) ;
Creer_triangle , Construire Des Actions ;
Deplacer Une Action ;
Kieme_triangle Une Fonction ( Liste De ( Entier , Entier ) ) ;
Infe Une Fonction ( Booleen ) ;
Init_list Une Action ;
Inserer Une Action ;
Trier Une Action ;
Animer_aleatoire Une Action ;
Animer_ordonnee Une Action ;
Redessiner Une Action ;
Parcours Une Action ;

Debut
Appel Construire ( List_triangle ) ;
Appel Trier ( List_triangle , List_trie ) ;
Appel Parcours ( List_triangle ) ;
Appel Parcours ( List_trie ) ;
/* Appel Animer_aleatoire */
/* Appel Animer_ordonnee */

Fin

PARCOURS DE LA LISTE DES TRIANGLES
Action Parcours ( List_triangle )
Soit
List_triangle Une Liste De Liste ( Entier , Entier ) ;
P Un Pointeur Vers Une Liste De Liste ( Entier , Entier ) ;
Q Un Pointeur Vers Une Liste De ( Entier , Entier ) ;

Debut
P := List_triangle ;
Tq P <> Nil
Ecrire ( 'liste :' ) ;
Q := Valeur ( P ) ;
Tq Q <> Nil
Ecrire ( Valeur ( Q ) ) ;
Q := Suivant ( Q ) ;
Ftq ;
P := Suivant ( P )
Ftq ;

Fin

CREATION D'UN TRIANGLE
Action Creer_triangle ( L , X1 , Y1 , X2 , Y2 , X3 , Y3 )
Soit
X1 , X2 , X3 , Y1 , Y2 , Y3 Des Entiers ;
L Une Liste De ( Entier , Entier ) ;
Q1 , Q2 Des Pointeurs Vers Des Listes De ( Entier , Entier ) ;
S Un ( Entier , Entier ) ;

Debut
Allouer ( L ) ;
Allouer ( Q1 ) ;
Allouer ( Q2 ) ;
I nit_struct ( S , [ X1 , Y1 ] ) ;
Aff_val ( L , S ) ;
Init_struct ( S , [ X2 , Y2 ] ) ;
Aff_val ( Q1 , S ) ;
Init_struct ( S , [ X3 , Y3 ] ) ;
Aff_val ( Q2 , S ) ;
Aff_adr ( L , Q1 ) ;
Aff_adr ( Q1 , Q2 ) ;
Aff_adr ( Q2 , Nil )
Fin

CREATION DE LA LISTE DES TRIANGLES
Action Construire ( L_triangle ) ;
Soit
I , N Des Entiers ;
Triangle Une Liste De ( Entier , Entier ) ;
L_triangle Une Liste De Liste De ( Entier , Entier ) ;
X1 , X2 , X3 , Y1 , Y2 , Y3 Des Entiers ;
P , Q Des Pointeurs Vers Des Listes De Listes De ( Entier , Entier ) ;

Debut
Lire ( N ) ;
P := Nil ;
Pour I := 1 , N
Lire ( X1 , Y1 ) ;
Lire ( X2 , Y2 ) ;
Lire ( X3 , Y3 ) ;
Appel Creer_triangle ( Triangle , X1 , Y1 , X2 , Y2 , X3 , Y3 ) ;
Allouer ( Q ) ;
Aff_val ( Q , Triangle ) ;
Si P <> Nil
Aff_adr ( P , Q )
Sinon
L_triangle := Q
Fsi ;
P := Q
Fpour ;
Aff_adr ( Q , Nil ) ;

Fin

TRANSFORMATION D'UN TRIANGLE PAR DEPALCEMENT
Action Deplacer ( Triangle , N , Sens ) ;
Soit
Triangle Une Liste De ( Entier , Entier ) ;
N Un Entier ;
Sens Un Entier ;

Debut
Si Sens = 1 { droit }
X1 := Struct ( Valeur ( Triangle ) , 1 ) + N ;
Si X1 > 80
X1 := X1 - 80 ;
Fsi ;
Aff_struct ( Valeur ( Triangle ) , 1 , X1 ) ;
X2 := Struct ( Valeur ( Suivant ( Triangle ) ) , 1 ) + N ;
Si X2 > 80 :
X2 := X2 - 80 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Triangle ) ) , 1 , X2 ) ;
X3 := Struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 1 ) + N ;
Si X3 > 80 :
X3 := X3 - 80 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 1 , X3 ) ;

Fsi ;
Si Sens = 2 { gauche }
X1 := Struct ( Valeur ( Triangle ) , 1 ) - N ;
Si X1 < 1
X1 := 80 + X1 ;
Fsi ;
Aff_struct ( Valeur ( Triangle ) , 1 , X1 ) ;
X2 := Struct ( Valeur ( Suivant ( Triangle ) ) , 1 ) - N ;
Si X2 < 1 :
X2 := 80 + X2 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Triangle ) ) , 1 , X2 ) ;
X3 := Struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 1 ) - N ;
Si X3 < 1 :
X3 := 80 + X3 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 1 , X3 ) ;

Fsi ;
Si Sens = 3 { bas }
Y1 := Struct ( Valeur ( Triangle ) , 2 ) + N ;
Si Y1 > 25
Y1 := Y1 - 25 ;
Fsi ;
Aff_struct ( Valeur ( Triangle ) , 2 , Y1 ) ;
Y2 := Struct ( Valeur ( Suivant ( Triangle ) ) , 2 ) + N ;
Si Y2 > 25
Y2 := Y2 - 25 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Triangle ) ) , 2 , Y2 ) ;
Y3 := Struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 2 ) + N ;
Si Y3 > 25
Y3 := Y3 - 25 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 2 , Y3 ) ;

Fsi ;
Si Sens = 4{ haut }
Y1 := Struct ( Valeur ( Triangle ) , 2 ) - N ;
Si Y1 < 1
Y1 := 25 + Y1 ;
Fsi ;
Aff_struct ( Valeur ( Triangle ) , 2 , Y1 ) ;
Y2 := Struct ( Valeur ( Suivant ( Triangle ) ) , 2 ) - N ;
Si Y2 < 1
Y2 := 25 + Y2 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Triangle ) ) , 2 , Y2 ) ;
Y3 := Struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 2 ) - N ;
Si Y3 < 1
Y3 := 25 + Y3 ;
Fsi ;
Aff_struct ( Valeur ( Suivant ( Suivant ( Triangle ) ) ) , 2 , Y3 ) ;
Fsi ;
Fin

K-IEME TRIANGLE DE LA LISTE
Fonction Kieme_triangle ( List_triangle , K ) : Liste De ( Entier , Entier )
Soit
List_triangle Une Liste De Liste De ( Entier , Entier ) ;
P Un Pointeur Vers Une Liste De Liste De ( Entier , Entier ) ;
I , K Des Entiers ;

Debut
I := 1 ;
P := List_triangle ;
Tq ( P <> Nil ) Et ( I < K )
P := Suivant ( P ) ;
I := I + 1
Ftq ;
Kieme_triangle := Valeur ( P )
Fin

RELATION D'ORDRE
Fonction Infe ( Tr1 , Tr2 ) : Booleen ;
Soit
Tr1 , Tr2 Des Listes De ( Entier , Entier ) ;

Debut
Infe := Faux ;
Si Struct ( Valeur ( Tr1 ) , 1 ) + Struct ( Valeur ( Suivant ( Tr1 ) ) , 1 ) + Struct ( Valeur ( Suivant (
Suivant ( Tr1 ) ) ) , 1 ) <= Struct ( Valeur ( Tr2 ) , 1 ) + Struct ( Valeur ( Suivant ( Tr2 ) ) , 1 ) + Struct (
Valeur ( Suivant ( Suivant ( Tr2 ) ) ) , 1 )
Infe := Vrai
Fsi
Fin

INITIALISATION D'UNE NOUVELLE LISTE AVEC LE PLUS GRAND TRIANGLE
DE L'ANCIENNE LISTE
Action Init_list ( L_init , L_res , Rang )
Soit
P , L_res , L_init Des Pointeurs Vers Des Listes De Listes De ( Entier , Entier ) ;
Maxi Une Liste De ( Entier , Entier ) ;
I , Rang Des Entiers ;

Debut
/* plus grand triangle */
Maxi := Valeur ( L_init ) ;
Rang := 1 ;
P := Suivant ( L_init ) ;
I := 2 ;
Tq P <> Nil
Si Infe ( Maxi , Valeur ( P ) )
Maxi := Valeur ( P ) ;
Rang := I ;
Sinon
P := Suivant ( P ) ;
I := I + 1
Fsi
Ftq ;
Allouer ( L_res ) ;
Aff_val ( L_res , Maxi ) ;
Aff_adr ( L_res , Nil ) ;
Fin

INSERTION D'UN ELEMENT DANS UNE LISTE ORDONNEE
Action Inserer ( Prec , L , V ) ;
Soit
Q , L , Prec Des Listes De Liste De ( Entier , Entier ) ;
V Une Liste De ( Entier , Entier ) ;

Debut
Si ( L <> Nil )
Si Infe ( V , Valeur ( L ) )
Allouer ( Q ) ;
Aff_val ( Q , V ) ;
Aff_adr ( Q , L ) ;
Si Prec = Nil
L := Q
Sinon
Aff_adr ( Prec , Q )
Fsi
Sinon
Appel Inserer ( L , Suivant ( L ) , V )
Fsi
Fsi
Fin

TRI D'UNE LISTE DE TRIANGLES
Action Trier ( L_init , L_res )
Soit
Prec , P , L_res , L_init Des Pointeurs Vers Des Listes De Listes De ( Entier , Entier ) ;
I , Rang Des Entiers ;

Debut
Appel Init_list ( L_init , L_res , Rang ) ;
Prec := Nil ;
P := L_init ;
I := 1 ;
Tq P <> Nil
Si I <> Rang
Appel Inserer ( Prec , L_res , Valeur ( P ) ) ;
Fsi ;
P := Suivant ( P ) ;
I := I + 1
Ftq ;
Fin

ANIMATION ALEATOIRE
Action Animer_aleatoire ; Debut
Tq 5 > 0 :
Appel Deplacer ( Kieme_triangle ( List_triangle , Aleanombre ( 20 ) ) ,
Aleanombre ( 12 ) , Aleanombre ( 4 ) + 1 ) ;
Appel Redessiner ;
Ftq
Fin

ANIMATION ORDONNEE
Action Animer_ordonnee ;
Soit
P Un Pointeur Vers Une Liste De Liste De ( Entier , Entier ) ;
Debut
Tq 5 > 0 :
Appel Trier ( List_triangle , List_trie ) ;
P := List_trie ;
Tq P <> Nil
Appel Deplacer ( Valeur ( P ) , Aleanombre ( 12 ) , Aleanombre ( 4 ) + 1 ) ;
Appel Redessiner ;
Ftq
Ftq
Fin
Action Redessiner Debut
/* effacer l'écran et redessiner tous les triangles
figurant dans la nouvelle liste */
Fin