Langage C

Calcul :somme, produit, division et modulo de deux entiers

//Télécharger Programme :  http://zipansion.com/FUVD

#include<stdio.h>
int main()
{ int a,b,s,p;
float d;
printf("donner a: ");
scanf("%d",&a);
printf("donner b: ") ;
scanf("%d",&b);
s=a+b;
p=a*b;
printf(" %d + %d= %dn",a,b,s);
printf(" %d * %d= %dn",a,b,p);
if (b!=0)
{
d=(float)a/b;//cast
printf(" %d / %d= %fn",a,b,d);
printf("%d Modulo %d =%dn",a,b, a%b ) ;
}
else
{
printf("erreurn");
}

return 0;
}

parité d'un nombre

//Télécharger :  http://zipansion.com/G5LV

#include<stdio.h>
#include<stdlib.h>

int main()
{ int a;
printf("donner un nombre ");
scanf("%d",&a);
if(a%2==0)
{
printf("%d est pair n",a);
}
else{
printf("%d non pair n",a);
}

system("pause");
}

Afficher les nombres entre 0 et 100 en 10 lignes en utilisant la boucle FOR

 

//Télécharger : http://zipansion.com/G5iO

#include<stdio.h>

#include<stdlib.h>

int main()
{ int i;
for (i=0;i<=100;i++)
{
if (i%10==0){
printf("n");
}
printf("%d ",i);
}

system("pause");
}

Afficher les nombres entre 0 et 100 en 10 lignes en utilisant la boucle WHILE

//Télécharger :  http://zipansion.com/G5iO

#include<stdio.h>
#include<stdlib.h>

int main()
{ int i=0;

while(i<=100){
if (i%10==0){
printf("n");
}
printf("%d ",i);
i++;
}

system("pause");
}

Afficher les nombres entre 0 et 100 en 10 lignes en utilisant la boucle DO ... WHILE

//Télécharger :  http://zipansion.com/G6Ai

#include<stdio.h>

#include<stdlib.h>

int main()

{ int i=0;

do

{

if (i%10==0){

printf("n");

}

printf("%d ",i);

i++;

}

while(i<=100);

 

system("pause");

}

 

contrôle de saisi: Saisir un nombre entre 0 et 20

//Télécharger : http://zipansion.com/G6Kt

#include<stdio.h>

#include<stdlib.h>

int main()

{ int a=0;

 

do

{

printf("donner note ");

 

scanf("%d",&a);

if ((a<0)||(a>20))

{

printf("saisir svp un nobre entre 0 20n");

 

}

}

while ((a<0)||(a>20));

 

system("pause");

}

 

contrôle de saisi avec fonction: Saisir un nombre entre 0 et 20

// Télécharger : http://zipansion.com/G6aj

#include<stdio.h>

#include<stdlib.h>

int controle(){

int a;

do

{

printf("donner note ");

 

scanf("%d",&a);

if ((a<0)||(a>20))

{

printf("saisir svp un nobre entre 0 20n");

 

}

}

while ((a<0)||(a>20));

return a;

 

}

int main()

{ int n;

 

n=controle();

printf("saisi Okn");

system("pause");

}

 

Somme des nombres pair entre 0 et 100

//Télécharger : http://zipansion.com/G6hm

#include<stdio.h>

#include<stdlib.h>

int main()

{ int i,s1=0,s2=1;

for(i=0;i<=100;i++)

{

if (i%2==0)

{

s1=s1+i;

}

 

else{

 

s2=s2+i;

 

}

 

}

printf("la somme des nobres pair est %dn",s1);

printf("la somme des nobres impair est %dn",s2);

system("pause");

}

opération avec switch - case

//Télécharger: http://zipansion.com/G6pL

#include<stdio.h>

#include<stdlib.h>

 

int main()

{ int a,b,c,s,p;

float d;

 

printf("                      MENUnn");

printf(" 1---------------------sommen");

printf(" 2---------------------produitn");

printf(" 3---------------------divisionn");

 

printf("donner a:");

scanf("%d",&a);

printf("donner b :");

scanf("%d",&b);

printf("donner votre choix :");

scanf("%d",&c);

switch(c)

{

case 1:

s=a+b;

printf("la somme de %d et %d est %dn",a,b,s);break;

case 2:

p=a*b;

printf("le produit de %d et %d est %dn",a,b,p);  break;

case 3:

if (b!=0){

d=(float)a/b;

printf("la de %d et %d est %0.2fn",a,b,d);

}

else{

printf("erreurn");

}

break;

default:

printf("taper svp  1  2  3 n" );

}

system("pause");

}

factoriel et maxi

//Télecharger : http://zipansion.com/G6zz

#include<stdio.h>

#include<stdlib.h>

int fac (int x)

{

int i,f=1;

for(i=1;i<=x;i++)

{

f=f*i;

}

return f;

}

int max( int x, int y)

{

if( x>y) return x;

else return y;

 

}

int main()

{

int n,p;

printf("donner n");

scanf("%d",&n);

printf("donner p");

scanf("%d",&p);

 

printf("le C(n,p)= %fn",(float)fac(n)/(fac(p)*fac(n-p)));

 

printf("le max de %d et %d est %d n",n,p,max(n,p));

 

system("pause");

 

}

le maxi de 4 entiers

//Télécharger: http://zipansion.com/G7EO

#include<stdio.h>

#include<stdlib.h>

int MAX(int x,int y)//fct

{

if (x>y) return x;

else return y;

}

void bjr()//procedure

{    printf("bonjourn");

}

 

int main()

{ int a,b,c,d;

bjr();

printf("entrer a");

scanf("%d",&a);

printf("entrer b");

scanf("%d",&b);

printf("entrer c");

scanf("%d",&c);

printf("entrer d");

scanf("%d",&d);

printf("le maxi est %dn",MAX(MAX(a,b),MAX(c,d)));

 

 

system("pause");

}

 

Table de multiplication (de 1 à 9)

//Télécharger: http://zipansion.com/G7Tv

#include <stdio.h>

#include <stdlib.h>

 

int main () {

int i,j,n;

printf("       table multiplicationn");

printf("X|t");

for(j=1;j<10;j++)printf("%dt",j);

printf("n------------------------------------------------------------------------n");

for(j=1;j<10;j++)

{

printf("%d|t",j);

for(i=1;i<10;i++)

{

printf("%dt",j*i);

 

}

printf("n------------------------------------------------------------------------n");

}

system("pause");

 

}

Factoriel récursive et itérative

//Télécharger : http://zipansion.com/G7aK

#include <stdio.h>
#include<stdlib.h>

int fact1(int a)

{int i,p=1;

for (i=1;i<=a;i++)

{p=p*i;

}

return p;

}

int fact2(int a)

{if ((a==0) || (a==1) )return 1;

else return a*fact2(a-1);;

}

int main()

{int a;

printf("donner a: ");scanf("%d",&a);

printf("1ere methode :factoriel de %d est %d n",a,fact1(a));

printf("2eme methode :factoriel de %d est %d n",a,fact2(a));

system("PAUSE");

}

les fonctions: factoriel, maxi ,produit ... en C

//Télécharger:  http://zipansion.com/G81k

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

int MAX(int x ,int y)

{

if (x>y) return x;

else return y;

}

int somme(int x,int y)

{

return x+y;

}

int produit(int x,int y)

{

return x*y;

}

float racine(int x)

{return sqrt(x);

}

 

int fac(int x)

{

int i,f=1;

for(i=1;i<=x;i++)

{

f*=i;

}

return f;

}

 

int fac2(int x)

{

if (x==0) return 1;

else return x*fac2(x-1);

 

}

 

int puissance(int x , int y)

 

{int p=1,i;

for(i=1;i<=y;i++)

{

p=p*x;

}

return p;

}

 

int main()

{ int a,b,c;

do{

printf("menun");

printf(" 1---------------------sommen");

printf(" 2---------------------produitn");

printf(" 3---------------------racinen");

printf(" 4---------------------facton");

printf(" 5---------------------puissancen");

printf(" 6---------------------maxn");

printf(" 7---------------------finn");

printf("entrer a :");scanf("%d",&a);

printf("entrer b :");scanf("%d",&b);

printf("entrer votre choix :");scanf("%d",&c);

switch(c)

{

case 1:

printf("la somme est %d n",  somme(a,b));

break;

case 2:

printf("le produit est %dn",   produit(a,b)  );

break;

case 3:

printf("la racine carre est %0.2fn", racine(a)    );

break;

case 4:

printf("le factoriel est %dn", fac(a)    );

printf("le factoriel est %dn", fac2(a)    );

break;

case 5:

printf(" %d a la puissance %d est %f n",a,b,pow(a,b));

printf(" %d a la puissance %d est %d n",a,b,puissance(a,b));

break;

case 6:

printf(" le max de %d  et % d est %d n",a,b,MAX(a,b));

 

break;

default:

printf("saisir svp 1/2/3/4/5/6 n");

 

}

}while(c!=7);

system("pause");

}

décomposer un nombre en millier centaine, dizaine et unité

//Télécharger :  http://zipansion.com/G8B0

#include<stdio.h>

#include<stdlib.h>

 

int main()

{ int n,m,c,d,u;

printf("donner un nombre :");

scanf("%d",&n);

m=n/1000;

printf("millier %d :n",m);

c= (n-m*1000)/100;//(n%1000)/100

printf("centaine %d :n",c);

d= (n-m*1000-c*100)/10;

printf("dizaine %d :n",d);

u=(n-m*1000-c*100-d*10);

printf("unite %d :n",u);

system("pause");

}

Calcul du pgdc (récursive)et ppmc

//Télécharger : http://zipansion.com/G8Hx

#include<stdio.h>

int pgcd(int a,int b){

if (b==0)

return a;

else

return pgcd(b,a%b);

 

}

 

main()

{int a,b;

printf("donner a   ");

scanf("%d",&a);

printf("donner b   ");

scanf("%d",&b);

printf("pgcd %dn",pgcd(a,b));

printf("ppmc %dn",a*b/pgcd(a,b));

 

}

Calcul du pgdc (itérative)

//Télécharger: http://zipansion.com/G8Ox

#include<stdio.h>

int pgcd(int a,int b){

int r;

 

while (a!=b){

 

if (a>b){

a=a-b;

pgcd(a,b);

 

}

else{

b=b-a;

pgcd(a,b);

}

 

}

return a;

 

 

}

 

main()

{int a,b;

printf("donner a   ");

scanf("%d",&a);

printf("donner b   ");

scanf("%d",&b);

printf("pgcd %d",pgcd(a,b));

 

 

}

Équation 2 degré

//Télécharger: http://zipansion.com/G8Xc

#include <stdio.h>

#include <math.h>

main()

{

/* Calcul des solutions réelles d'une équation du second degré */

int A, B, C;

double D; /* Discriminant */

printf("Calcul des solutions reelles d'une equation du second n");

printf("degre de la forme   Ax^2 + Bx + C = 0 nn");

printf("Introduisez la valeur de A : ");

scanf("%d",&A);

printf("Introduisez la valeur de B : ");

scanf("%d",&B);

printf("Introduisez la valeur de C : ");

scanf("%d",&C);

/* Calcul du discriminant b^2-4ac */

D = pow(B,2) - 4.0*A*C;

 

/* Distinction des différents cas */

if (A==0 && B==0 && C==0) /* 0x = 0 */

printf("Tout reel est une solution de cette equation.n");

else if (A==0 && B==0)  /* Contradiction: c # 0 et c = 0 */

printf("Cette equation ne possede pas de solutions.n");

else if (A==0) /* bx + c = 0 */

{

printf("La solution de cette equation du premier degre est :n");

printf(" x = %lf ",(double)-C/B);

}

else if (D<0)  /* b^2-4ac < 0 */

printf("Cette equation n'a pas de solutions reelles.n");

else if (D==0) /* b^2-4ac = 0 */

{

printf("Cette equation a une seule solution reelle :n");

printf(" x =  %lf",(double)-B/(2*A));

}

else /* b^2-4ac > 0 */

{

printf("Les solutions reelles de cette equation sont :n");

printf(" x1 =%lf ", (double)(-B+sqrt(D))/(2*A));

printf(" x2 =%lf ", (double)(-B-sqrt(D))/(2*A));

}

getchar();

getchar();

}

annee bissextile

//Télécharger: http://zipansion.com/G8eW

#include <stdio.h>

#include <stdlib.h>

int main(  ) {

 

int annee;

 

printf("Saisir une date entre 1900 et 2100 : ");

scanf("%d",&annee);

if(annee >= 1900 || annee <= 2100)

{

if ((((annee % 4) == 0) && ((annee % 100) != 0))|| ((annee % 400) == 0))

 

 

 

printf("%d est une annee bissextilen",annee);

else

{

 

printf("%d n'est pas une annee bissextilen",annee);

}

 

}

 

system("pause");

return 0;

}

Fonction d'Ackermann

//Télécharger : http://zipansion.com/G8k8

#include <stdio.h>

 

void main()

{

int ackerman (int a, int b);

int a,b;

 

printf ("donnez la valeur de a et b : ");

scanf ("%d%d", &a, &b);

printf ("fonction ackerman est %d ", ackerman(a, b));

printf ("n");

}

 

int ackerman (int m, int n)

{

 

if (m==0)

return n+1 ;

else 

{

if (n==0)

return ackerman (m-1, 1);

else 

return ackerman(m-1,ackerman(m, n-1));

}

}

suite de Fibonacci

//Télécharger: http://zipansion.com/G8pr

/*

Ecrire un programme qui affiche le nième terme de la suite de Fibonacci, définie par la relation de récurence:

 

U(0) = U(1) = 1

Pout tout n >= 2 , Un = U(n -1) + U(n -2)

 

*/

 

 

 

#include <stdio.h>

 

 

 

int main()

{ int fib (int x);

int a, f;

printf ("donnez la valeur de a : ");

scanf ("%d", &a);

f=fib(a);

printf ("suite fibonnacci de %d est %dn", a, f);

return 0;

}

 

int fib (int x)

{

if ((x==0) || (x==1) )

{

return x ;

}

else

{

return  fib (x-1)+ fib (x-2) ;

}

}

Calcul puissance

//Télécharger: http://zipansion.com/G8ys

#include <stdio.h>

 

int main(){

 

int puissance (int x, int n);

int a, p;

printf ("donnez un nombre et  exposant : ");

scanf ("%d%d", &a, &p);

printf ("le nombre %d a la puissance %d est %d ", a, p, puissance( a, p));

printf ("n");

return 0;

}

int puissance (int x, int n)

{

int i;

for (i=1; i<n; i++)

{

x*=x;

}

return x;

}

 

 

Exercice affiche étoile modelé 1

//Télécharger: http://zipansion.com/G997

/*

***

*****

*******

*********

***********

*************

***************

 

*/

#include <stdio.h>

#include <stdlib.h>

main()

{

int nblig; /* nombre de lignes */

int i; /* compteur des lignes */

int nbesp; /* nombre d'espaces */

int j; /* compteur des caractères */

 

do

{

printf("Entrer le Nombre de lignes : ");

scanf("%d", &nblig);

}

while (nblig<1 || nblig>20);

 

for (i=0 ; i<nblig ; i++)

{

nbesp = nblig-i-1;

for (j=0 ; j<nbesp ; j++)

printf(" ");

for (j=0 ; j<2*i+1 ; j++)

printf("*");

printf("n");

}

system("PAUSE");

 

}

Exercice affiche étoile modelé 2

//Télécharger : http://zipansion.com/GBhr

#include <stdio.h>

#include <stdlib.h>

int main ()

{int y,j,i,p ;

 

printf ("ncombien de ligne ? n");

scanf ("%d",&y);

for(i=0;i<y;i++)

{printf ("n");

{for(j=0;j<=i;j++)

{printf ("*");

}

}

}

system("PAUSE");

}

Exercice affiche étoile modelé 3

//Télécharger: http://zipansion.com/GBot

#include <stdio.h>

#include <stdlib.h>

 

main()

{

int i,j,l,c;

printf("entrerz le nb d'etoiles ");

scanf("%d",& c);

printf("entrerz le nb de ligne");

scanf("%d",& l);

for(i=0;i<=c;i++)

{

for(j=1;j<=l;j++)

{

printf("*");

}

printf("n");

}

system("pause");

}

Exercice affiche étoile modelé 4

//Télécharger: http://zipansion.com/GByP

#include <stdio.h>

#include <stdlib.h>

main()

{

int nblig; /* nombre de lignes */

int i; /* compteur des lignes */

int nbesp; /* nombre d'espaces */

int j; /* compteur des caractères */

 

do

{

printf("Entrer le Nombre de lignes : ");

scanf("%d", &nblig);

}

while (nblig<1 || nblig>20);

printf("nn");

for (i=0 ; i<nblig ; i++)

{

nbesp = nblig-i-1;

for (j=0 ; j<nbesp ; j++)

printf(" ");

for (j=0 ; j<2*i+1 ; j++)

printf("*");

printf("n");

}

 

for (i=nblig-2 ; i>=0 ; i--)

{

nbesp = nblig-i-1;

for (j=0 ; j<nbesp ; j++)

printf(" ");

for (j=0 ; j<2*i+1 ; j++)

printf("*");

printf("n");

}

 

printf("nn");

system("PAUSE");

 

}

Nombres parfait entre 0 et 10000

//Télécharger : http://zipansion.com/GyCC

#include<stdio.h>

#include<stdlib.h>

#define nmax 10000

main()

 

 

{

long n, somme_diviseur, diviseur;

for(n=1; n<=nmax; n++)

{

somme_diviseur=0;

for(diviseur=1; diviseur<=n/2; diviseur++)

if(n%diviseur==0)

somme_diviseur+=diviseur;

if(somme_diviseur==n)

printf("%d est un nombre parfaitn", n);

}

 

system("pause");

}

Nombre premier

//Télécharger : http://www.safimen.com/C_safimen/28.txt

#include <stdio.h>

#include<stdlib.h>

 

int main (void)

{

int i, nb, compter, test;

test = compter = 0;

printf ("Entrez un nombre entier : ");

if (scanf ("%d", &nb) !=1)

{

return -1;

}

 

printf ("nb:%d n",nb);

 

if (nb % 2 == 0)

test = 1;

else{

for (i = 3 ; i < nb; i+=2, compter++)

if (nb % i == 0)

test = 1;

}

if (!test)

printf ("%d nombre premier, nombre iterations = %dn",

nb, compter);

else

printf ("%d n'est pas nombre premier, nombre iterations = %dn",nb, compter);

 

 

system("pause");

}

nombre armstrong entre 0 et 100

//Télécharger : http://www.safimen.com/C_safimen/29.txt

#include<stdio.h>

#include<stdlib.h>

main()

{

int n,mi2at,aacharat,wa7adat;

for(n=100;n<=999;n++){

mi2at = n/100;

aacharat = (n - mi2at*100)/10;

wa7adat = n - (mi2at*100 + aacharat * 10);

if(n == mi2at*mi2at*mi2at + aacharat*aacharat*aacharat + wa7adat*wa7adat*wa7adat)

printf("%dn",n);

}

system("pause");

}

calcul de la racine carré: Xi=(A/Xi-1 +Xi+1)/2

//Télécharger: http://zipansion.com/Gz5l

/*Cette méthode repose sur la connaissance d’une première valeur approchée de la racine de A notée a.

 

Il s’agit ensuite de calculer la moyenne arithmétique entre a et A/a (puisque ce sont deux valeurs approchées du nombre cherché).

 

On obtient alors : , il ne reste plus qu’à itérer le processus.

 

Xo=a;

Xi=(A/Xi-1 +Xi+1)/2

 

Cette méthode est très simple, puisqu’il s’agit à chaque étape, d’évaluer la moyenne arithmétique de deux approximations de la racine carrée de A.

 

En effet si est une valeur approchée par excès, alors est une valeur approchée par défaut (et réciproquement).

*/

 

#include <stdio.h>

#include <stdlib.h>

int main(  ) {

 

float x,n,i,d;

 

printf("programme racine carrenn");

printf("donner unnombre :");scanf("%f",&n);

printf("donner la valeur approchee du racine carre :");scanf("%f",&x);// c est l 'astuce du probleme il faut donner la valeur approchee du racine carree de n

 

for (i=1; i<=10;i++)

{

x=(n + x*x )/(2*x);

printf("%0.0f racine carre  %0.2fn",i ,x);

}

printf(" racine carre  %0.2fnn",x);

system("pause");

return 0;

}

 

 

 

Pointeur

//télécharger : http://zipansion.com/Gz4e

#include <stdio.h>

#include <cstdlib>

#include <conio.h>

main()

{

int a=8;

int *p;

p = (int*)malloc(sizeof(int));

p=&a;

printf("adresse  de a=%p   son contenu=%d n",&a,a);

printf("adresse  de p=%p   son contenu=%d n",p,*p);

 

printf("nPOUR CONTINUER FRAPPER UNE TOUCHE");

getch();

}

les tableaux et les pointeurs-1-

//Télécharger: http://zipansion.com/Gz1e

#include <stdio.h>

#include <stdlib.h>

#define N 5

int tab[5] = {0, 1, 4, 20, 7};

main()

{

int i;

int *p;

printf(" adresse de &tab[0]=%pn",&tab[0]);

printf(" adresse de    tab =%pn",tab);

p = tab; // tab equivalent de &tab[0]

printf(" adresse de      p =%pn",p);

 

 

for (i = 0; i < N; i++)

{

printf("%p  : %d n",p+i,*(p+i));

//p++;

}

system("pause");

}

Exercice pointeur :remplir tableau

voir correction rubrique C++ ( exercice pointeur remplir tableau )

Table de multiplication d 'un nombre

//Télécharger: http://zipansion.com/GyzS

#include <stdio.h>

#include <stdlib.h>

 

int main () {

int i,n;

printf("       table multiplicationn ");

do{

printf("donner n ");

scanf("%d",&n);

}while ((n<0)|| (n>9));

 

for(i=1;i<10;i++)

{

printf("%d X %d=%dn",n,i,n*i);

 

}

system("pause");

 

}

Tableaux et pointeurs-2-

//Télécharger :http://zipansion.com/Gywb

#include <stdio.h>

#include <stdlib.h>

 

main() {

int n ;

int *tab = NULL;

int *p;

int i ;

printf ("Veuillez entrer la taille du tab : n");

scanf ("%d", &n);

 

tab = (int *)malloc(sizeof(int) * n);

for (i = 0; i < n; i++) {

printf ("Veuillez entrer un nombre : ");

scanf ("%d", &tab[i]);

}

p = tab;

 

for (i = 0; i < n; i++)

{

printf("%p  : %d n",p,*p);

p++;

}

printf ("Veuillez entrer la taille du tab : n");

scanf ("%d", &n);

 

tab = (int *)malloc(sizeof(int) * n);

for (i = 0; i < n; i++) {

printf ("Veuillez entrer un nombre : ");

scanf ("%d", &tab[i]);

}

p = tab;

 

for (i = 0; i < n; i++)

{

printf("%p  : %d n",p,*p);

p++;

}

free(tab);

 

 

system ("pause");

 

}

Tableaux et pointeurs-3-

//Télécharger: http://zipansion.com/GzC5

#include <stdio.h>

#include <stdlib.h>

/*

 

déclaration

int tab[10];

int *tab;

tab=(int*)malloc(sizeof(int)*10);

 

le 1er élément

*tab                    tab[0]

 

un autre élément

 

*(tab+i)                  tab[i]

 

adresse du 1er élément

tab                    &tab[0]

 

adresse d'un autre élément

 

(tab + i)

 

 

*/

void init (int *tab, int n)

{

int i;

for (i = 0; i < n; i++)

tab[i] = i;

return;

}

void affichage( int *tab,int n)

{int i,*p;

p=tab;

for(i=0;i<n;i++)

printf("%dn",*(p+i));

}

 

main()

{

int i, n = 5;

int *tab;

tab = (int*)malloc(n * sizeof(int));

init(tab,n);

affichage(tab,n);

system("pause");

return 0;

}

Tableau et pointeur-4-

//Télécharger: http://zipansion.com/GzRI

#include <stdio.h>

#include <stdlib.h>

main()

{

int A[4];

int *P;

printf("Introduire 4 entiers : n");

for (P=A; P<A+4; P++)

scanf("%d", P);

 

printf("Tableau  A :n");

for (P=A; P<A+4; P++)

printf("%d ", *P);

printf("n");

system("PAUSE");

}

Affichage tableau par pointeur

//Télécharger: http://zipansion.com/GzXr

#include <stdio.h>

#include <stdlib.h>

 

#define N 5

int tab[5] = {1, 2, 6, 0, 7};

main()

{

int *p;

printf("n ordre croissant:n");

for (p = &tab[0]; p <= &tab[N-1]; p++)

printf(" %d n",*p);

printf("n ordre decroissant:n");

for (p = &tab[N-1]; p >= &tab[0]; p--)

printf(" %d n",*p);

system ("pause");

}

Triangle de pascal

//Télécharger: http://zipansion.com/Gzdn

#include <stdio.h>

main()

{

/* Déclarations */

int P[14][14]; /* matrice résultat  */

int N;         /* degré du triangle */

int I, J;      /* indices courants  */

/* Saisie des données */

do {

printf("Entrez le degré N du triangle (max.13) : ");

scanf("%d", &N);

} while (N>13||N<0);

/* Construction des lignes 0 à N du triangle: */

/* Calcul des composantes du triangle jusqu'à */

/* la diagonale principale. */

for (I=0; I<=N; I++)

{

P[I][I]=1;

P[I][0]=1;

for (J=1; J<I; J++)

P[I][J] = P[I-1][J] + P[I-1][J-1];

}

/* Edition du résultat */

printf("Triangle de Pascal de degré %d :n", N);

for (I=0; I<=N; I++)

{

printf(" N=%2d", I);

for (J=0; J<=I; J++)

if (P[I][J])

printf("%5d", P[I][J]);

printf("n");

}

return 0;

}

Somme de deux matrices

//Télécharger : http://zipansion.com/GzrM

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define N 2

#define M 3

//void afficher(int b[], int m);

 

int main (void)

{

int j,i,n,s=0;

 

int A[N][M],B[N][M],C[N][M];

 

 

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{ printf(" saisir la valeur de la matrice:A[%d][%d]n",i,j);

scanf("%d",&A[i][j]);

 

}

}

printf("nn");

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{ printf(" saisir la valeur de la matrice:B[%d][%d]n",i,j);

scanf("%d",&B[i][j]);

 

}

}

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{

C[i][j]=A[i][j]+B[i][j];

}

}

 

 

printf(" affichage de la matrice :A  n");

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{ printf("%d  ",A[i][j]);

 

 

}

printf("n");

}

printf("n");

printf(" affichage de la matrice :B  n");

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{ printf("%d  ",B[i][j]);

 

 

}

printf("n");

}

printf(" affichage de la matrice :C=A+B  n");

for(i=0;i<N;i++)

{

for(j=0;j<M;j++)

{ printf("%d  ",C[i][j]);

 

 

}

printf("n");

}

system("PAUSE");

 

}

 

 

/*

afficher (tab,max);

system("PAUSE");

 

}

 

void afficher( int b[],int y)

{ int i;

for (i=0 ;i<y;i++)

printf("%dn",b[i]);

 

}

*/

Affiche maxi et mini d'un tableau

//Télécharger: http://zipansion.com/GzyZ

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

 

void afficher_max_min(int b[],int d);

int main (void)

{

int i;

int N=4;

int tab1[4];

 

 

for(i=0;i<=N;i++)

{ printf(" saisir la valeur :tab1[%d]n",i);

scanf("%d",&tab1[i]);

}

 

afficher_max_min(tab1,N);

 

system("PAUSE");

 

}

void afficher_max_min(int b[],int d)

{int i,max,min;

max=min=b[0];

for(i=0;i<=d;i++)

{

printf("%d: %dn",i,b[i]);

max=(max>b[i] ? max:b[i]);

 

min=(min<b[i] ? min:b[i]);

}

 

 

 

printf("le max est : %d   le min est : %dn",max,min);

 

 

}

 

permuter deux nombres avec pointeur

//Télécharger : http://zipansion.com/HCdH

#include <stdio.h>

#include <stdlib.h>

void echange (int *adr_a, int *adr_b)

{

int t;

t = *adr_a;

*adr_a = *adr_b;

*adr_b = t;

return;

}

 

main()

{

int a = 2, b = 5;

printf("debut programme principal :n a = %d t b = %dn",a,b);

echange(&a,&b);

printf("fin programme principal :n a = %d t b = %dn",a,b);

 

 

system("pause");

return 0;

}

Recherche dans un tableau

//Télécharger : http://zipansion.com/HCjN

#include <stdio.h>

main()

{ int t[10];

int i, x, n, p;

printf ("donnez la taille : ");

scanf ("%d", &n);

 

for (i=0; i<n; i++)

{

printf ("donnez t[%d] ", i);

scanf ("%d", &t[i]);

}

p=-1;

printf ("donnez un nombre A CHERCHER ");

scanf ("%d", &x);

for (i=0; i<n; i++)

{

if (t[i]==x)

{

p=i ;

break ;

}

}

 

printf ("position : %dn ", p);

}

Recherche dichotomie

//Télécharger : http://zipansion.com/HCr0

#include <stdio.h>

#include <math.h>

#include<stdlib.h>

// le tableau doit etre triee( principe dichotomie)

main(){

 

int A[50];

int VAL;

int POS;

int N;

int I;

int INF, MIL, SUP;

 

/* Saisie des données */

printf("Dimension du tableau (max.50) : ");

scanf("%d", &N );

for (I=0; I<N; I++)

{

printf("ElEment %d : ", I);

scanf("%d", &A[I]);

}

printf("ElEment à rechercher : ");

scanf("%d", &VAL );

 

printf("Tableau donne : n");

for (I=0; I<N; I++)

printf("%d ", A[I]);

printf("n");

 

INF=0;

SUP=N-1;

 

POS=-1;

while ((INF<=SUP) && (POS==-1))

{

MIL=(SUP+INF)/2;

if (VAL < A[MIL])

SUP=MIL-1;

else if (VAL > A[MIL])

INF=MIL+1;

else

POS=MIL;

}

 

 

if (POS==-1)

printf("La valeur recherchee ne se trouve pas "

"dans le tableau.n");

else

printf("La valeur %d se trouve à la position %d. n",

VAL, POS);system("pause");

}

matrice unitaire

//Télécharger : http://zipansion.com/HCvv

#include <stdio.h>

 

#include<stdlib.h>

main(){{ int t[10][10];

int i, j, l, c;

printf ("donnez le nombres des lignes : " );

scanf ("%d", &l);

printf ("donnez le nombre des colonnes : ");

scanf ("%d", &c);

for (i=0; i<l; i++)

{

for (j=0; j<c; j++)

{

if (i==j)

{

t[i][j]=1;

}

else

t[i][j]=0;

}

}

for (i=0; i<l; i++)

{

for (j=0; j<c; j++)

{

printf ("%dt", t[i][j]);

}

printf ("n");

}

system("pause");

}

}

Transposé matrice

//Télécharger : http://zipansion.com/HD1A

#include <stdio.h>

main()

{

 

int A[50][50];

int B[50][50];

int N, M;

int I, J;

printf("Nombre de lignes   (max.50) : ");

scanf("%d", &N );

printf("Nombre de colonnes (max.50) : ");

scanf("%d", &M );

for (I=0; I<N; I++)

for (J=0; J<M; J++)

{

printf("Elément[%d][%d] : ",I,J);

scanf("%d", &A[I][J]);

}

printf("Matrice donnée :n");

for (I=0; I<N; I++)

{

for (J=0; J<M; J++)

printf("%7d", A[I][J]);

printf("n");

}

for (I=0; I<N; I++)

for (J=0; J<M; J++)

B[J][I]=A[I][J];

 

printf("Matrice résultat :n");

for (I=0; I<M; I++)

{

for (J=0; J<N; J++)

printf("%7d", B[I][J]);

printf("n");

}

return 0;

}

Carré magique (nombre impair)

//Télécharger : http://zipansion.com/HD6i

#include <stdio.h>

#include<stdlib.h>

#define N  100

 

int     a[N][N];

int     n;

 

void Init (int n)

{

int i, j;

 

for (i = 0 ; i < n; ++i)

for (j = 0; j < n; ++j)

a[i][j] = 0;

}

 

void Magique (int n)

{

int i, j, k;

 

i = n - 1; j = n / 2;

for (k = 1; k <=  n * n; ++k) {

a[i][j] = k;

if ((k % n) == 0)

i = i - 1;

else {

i = (i + 1) % n;

j = (j + 1) % n;

}

}

}

 

void Erreur (char s[])

{

printf ("Erreur fatale: %sn", s);

exit (1);

}

 

void Lire (int *n)

{

printf ("Taille du carre' magique, svp?::  ");

scanf ("%d", n);

if ((*n <= 0) || (*n > N) || (*n % 2 == 0))

Erreur ("Taille impossible.");

}

 

void Imprimer (int n)

{

int i, j;

 

for (i = 0; i < n; ++i) {

for (j = 0; j < n; ++j)

printf ("%4d ", a[i][j]);

printf ("n");

}

}

 

int main ()

{

Lire(&n);

Init(n);       /* - */

Magique(n);

Imprimer(n);

system("pause");

return 0;

}

decimal to binary

//Télécharger : http://zipansion.com/HDBT

#include <stdio.h>

#include<stdlib.h>

#include <math.h>

 

int main()

{

int q=1,i=0,nombre=0;

double b=0;

scanf("%d",&nombre);

 

while(q != 0)

{

b=(b+((nombre%2)*pow(10,i)));

nombre=nombre/2;

q=nombre;

i++;

}

printf("ce nombre en  binaire est %0.0lfn" ,b);

system ("pause");

return 0;

}

Trie Tableau

//Télécharger :http://zipansion.com/HDKv

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

//#include<system.h>

///////////////////////////

void echange1(int *t,int i,int j)

{

int tmp;

tmp=t[i];

t[i]=t[j];

t[j]=tmp;

}

 

 

void tribulle(int*t,int n)

{

int i,p;

do {

p=1;

for(i=0;i<n-1;i++)

{

if(t[i]>t[i+1]) {echange1(t,i,i+1); p=0; }

}

}while(p==0);

}

 

 

 

///////////////////////////

 

void insertion(int *t,int n)

{

int tmp,i,j;

for(i=1;i<n;i++)

{

tmp=t[i];

j=i;

while(t[j-1]>tmp && j>0) { t[j]=t[j-1]; j--; } t[j]=tmp;

}

}

 

///////////////////////////

 

void echange(int *t,int i,int j)

{

int tmp;

tmp=t[i];

t[i]=t[j];

t[j]=tmp;

}

 

int Min(int *t,int n,int i)

{

int m=t[i],p=i,j;

 

for(j=i+1;j<n;j++)

{

if(t[j]<m)

{

m=t[j];

p=j;

}

}

return p;

}

 

void triselection(int *t,int n)

{

int i,j;

for (i=0;i<n-1;i++) echange(t,i,Min(t,n,i));

}

 

///////////////////////////

 

void fusion(int *t1,int d1, int f1,int *t2,int d2, int f2,int *tf)

{ int i=d1,j=d2,k=d1;

while(i<=f1&&j<=f2)

if(t1[i]<t2[j])

tf[k++]=t1[i++];

else

tf[k++]=t2[j++];

while(i<=f1)

tf[k++]=t1[i++];

while(j<=f2)

tf[k++]=t1[j++];

}

 

void decoupfusion(int *t,int d, int f,int *tf)

{

int m,i;

if(d!=f)

{

m=(d+f)/2;

decoupfusion(t,d,m,tf);

decoupfusion(t,m+1,f,tf);

fusion(t,d,m,t,m+1,f,tf);

for(i=d;i<=f;i++)

t[i]=tf[i];

}

}

 

void trifusion(int *t,int n)

{int *tf;

tf=malloc(n*sizeof(int*));

decoupfusion(t,0,n-1,tf);

}

 

///////////////////////////

 

void permut(int*t,int i,int j)

{

int tmp;

tmp=t[i];

t[i]=t[j];

t[j]=tmp;

}

 

int partition(int *t,int d,int f)

{

int i,j=d,p=t[f];

for(i=d;i<f;i++)

if(t[i]<p)

permut(t,i,j++);

permut(t,j,f);

return j;

}

 

void triRapide(int *t,int d,int f)

{int p;

if(d<f)

{p=partition(t,d,f);

triRapide(t,d,p-1);

triRapide(t,p+1,f);

}

}

 

///////////////////////////

 

 

void saisitab(int n,int i,int *t)

{

if(i<n)

{

t[i]=0+rand()%60;

saisitab(n,i+1,t);

}

}

void affichagetab(int *t,int n,int i)

{

if(i<n)

{

printf(" %d ",t[i]);

affichagetab(t,n,i+1);

}

}

 

 

main()

{

int *t,n,c;

srand(time(NULL));

printf("Menun");

printf("1----Tri Par Selectionn");

printf("2----Tri Par insertionn");

printf("3----Tri Par Bullen");

printf("4----Tri Par Fusionn");

printf("5----Tri Rapiden");

printf("6----Exitnnnn");

printf("Donner La taille Du tableau : ");

scanf("%d",&n);

t=malloc(sizeof(int)*n);

saisitab(n,0,t);

affichagetab(t,n,0);

printf("n");

 

 

 

do {

printf("Donner votre Choix : ");scanf("%d",&c);

switch(c)

{

case 1:

printf("---------------------nTrie Par Selectionn---------------------n");

printf("Avantn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n");

triselection(t,n);

printf("Apresn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n")

;break;

case 2:

printf("---------------------nTrie Par Insertionn---------------------n");

printf("Avantn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n");

insertion(t,n);

printf("Apresn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n")

;break;

case 3:

printf("---------------------nTrie Par Bullen---------------------n");

printf("Avantn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n");

tribulle(t,n);

printf("Apresn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n")

;break;

case 4:

printf("---------------------nTrie Par Fusionn---------------------n");

printf("Avantn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n");

trifusion(t,n);

printf("Apresn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n")

;break;

case 5:

printf("---------------------nTrie Rapiden---------------------n");

printf("Avantn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n");

triRapide(t,0,n-1);

printf("Apresn");

affichagetab(t,n,0);

printf("n----------------------------------------------------------------------------n")

;break;

case 6:printf("Byn");break;

default : printf("Erreurn");

}

}while(c!=6);

}

Structure nombre complexe

//Télécharger : http://zipansion.com/HDRJ

#include <stdio.h>

#include <stdlib.h>

struct complexe{

int x,y;

};

void saisi(complexe *c1)

{   printf("donner c1.x ");scanf("%d",&c1->x);

printf("donner c1.y ");scanf("%d",&c1->y);

}

void affiche(complexe *c1)

{   printf("(%d,%d) n",c1->x,c1->y);

}

void somme(complexe *c1,complexe *c2 ,complexe *c3){

c3->x=c1->x+c2->x;

c3->y=c1->y+c2->y;

}

complexe somme(complexe *c1,complexe *c2 ){

complexe c3;

c3.x=c1->x+c2->x;

c3.y=c1->y+c2->y;

return c3  ;

}

complexe somme2(complexe *c1,complexe *c2 ){

complexe *c3;

c3=(complexe*)  malloc(sizeof(complexe));

c3->x=c1->x+c2->x;

c3->y=c1->y+c2->y;

return *c3  ;

}

complexe *somme3(complexe *c1,complexe *c2 ){

complexe *c3;

c3=(complexe*)  malloc(sizeof(complexe));

c3->x=c1->x+c2->x;

c3->y=c1->y+c2->y;

return c3  ;

}

int main () {

complexe *c1,*c2,*c3;

c1=(complexe*)  malloc(sizeof(complexe));

c2=(complexe*)  malloc(sizeof(complexe));

c3=(complexe*)  malloc(sizeof(complexe));

saisi( c1);

saisi( c2);

affiche(c1);

affiche(c2);

somme(c1,c2,c3);

affiche(c3);

*c3= somme(c1,c2 );

affiche(c3);

*c3= somme2(c1,c2 );

c3= somme3(c1,c2 );

affiche(c3);

printf("n");

free(c1);free(c2);

system("pause");

return 0;

}

Redimensionner tableau

//Télécharger :  http://zipansion.com/HDXq

#include <stdio.h>

#include <stdlib.h>

 

int main () {

int t1[4],*t2,i,n;

printf("donner taille du tableau NUM 2 ");scanf("%d",&n);

t2=(int*)malloc(sizeof(int)*n);// t2 tableau dynamique.   t1 tableau statique

for(i=0;i<4;i++)

{printf("donnr t1[%d]",i);

scanf("%d",&t1[i]);

}

for(i=0;i<4;i++)

{printf("%d t",t1[i]);

}

printf("n");

for(i=0;i<n;i++)

{printf("donnr t2[%d]",i);

scanf("%d",&t2[i]);

}

for(i=0;i<n;i++)

{printf("%d t",t2[i]);

}

printf("n");

printf("REdonner taille du tableau ");scanf("%d",&n);

t2=(int*)realloc(t2,sizeof(int)*n);

printf("n");

for(i=0;i<n;i++)

{printf("donnr t2[%d]",i);

scanf("%d",&t2[i]);

}

for(i=0;i<n;i++)

{printf("%d t",t2[i]);

}

printf("n");

system("pause");

return 0;

}

Saisie et affichage tableau avec pointeur

//Télécharger :  http://zipansion.com/HDnN

#include <stdio.h>

#include <stdlib.h>

void saisi(int *t2,int *n)

{int i;

for(i=0;i<*n;i++)

{printf("donnr t2[%d]",i);scanf("%d",(t2+i));

}

}

void affichage(int *t2,int *n)

{int i;

for(i=0;i<*n;i++)

{printf("%dt",*(t2+i));

}

printf("n");

}

void    somme(int *t2,int t3[],int *t4,int n){

int i;

for (i=0;i<n;i++)

{

//  t4[i]=t2[i]+t3[i];

*(t4+i)=*(t2+i)+*(t3+i);

}

 

}

 

int main () {

 

int *t2,*t3,*t4,i,n;

 

printf("donner taille du tableau ");scanf("%d",&n);

t2=(int*)malloc(sizeof(int)*n);

t3=(int*)malloc(sizeof(int)*n);

t4=(int*)malloc(sizeof(int)*n);

saisi(t2, &n);

affichage(t2,&n);

 

saisi(t3, &n);

affichage(t3,&n);

 

somme(t2,t3,t4,n);

affichage(t4,&n);

 

printf("n");

system("pause");

return 0;

}

Structure (composé)cercle et point

//Télécharger :  http://zipansion.com/HDx1

#include<stdio.h>

#include<stdlib.h>

struct point{

int x;

int y;

};

struct cercle{

point p;

int  rayon;

float s;

};

struct carre{

point p1;

point p2;

float s;

};

int main()

{cercle c;

carre ca;

//saisi cercle

printf("donner c.p.x ");scanf("%d",&c.p.x);

printf("donner c.p.y ");scanf("%d",&c.p.y);

printf("donner c.rayon ");scanf("%d",&c.rayon);

c.s=3.14*c.rayon*c.rayon;

printf("(%d,%d) rayon=%d  surface =%f n",c.p.x,c.p.y,c.rayon,c.s);

//saisi carre

printf("saisi premier point n");

printf("donner ca.p1.x ");scanf("%d",&ca.p1.x);

printf("donner ca.p1.y ");scanf("%d",&ca.p1.y);

printf("saisi 2eme point n");

printf("donner ca.p2.x ");scanf("%d",&ca.p2.x);

printf("donner ca.p2.y ");scanf("%d",&ca.p2.y);

ca.s=(ca.p2.x - ca.p1.x)*(ca.p2.y - ca.p1.y);

printf("%fn",ca.s);

system("pause");

}

 

structure banque

//Télécharger :  http://zipansion.com/HE4R

#include <stdio.h>

#include<stdlib.h>

struct compte{

int num;

char nom[20];

float montant;

}c1;

void depot(float m){

c1.montant +=m;//c1.montant =c1.montant+m;

}

void retrait(float m){

if(c1.montant>=m) c1.montant -=m;//c1.montant =c1.montant -=m-m

else printf("solde insuffisant ..!!");

}

main(){

 

int choix;

float somme;

printf("entrer le nom:"); scanf("%s",c1.nom);

printf("entrer le num:"); scanf("%d",&c1.num);

c1.montant=0;

do{

printf("La somme:%gn",c1.montant);

printf("1 : DEPOSERn2 : RETIRERn0 : SORTIRnENTRER VOTRE CHOIX");

scanf("%d",&choix);

printf("entrer la somme à diposer/retirer:");

scanf("%f",&somme);

 

 

 

switch(choix){

case  1: depot(somme); break;

case  2:retrait(somme); break;

}

 

 

 

}while(choix!=0);

system("pause");

}

 

Structure -1-

//Télécharger :http://zipansion.com/HEC6

#include <stdio.h>

#include<stdlib.h>

struct compte{

int num;

char nom[20];

float montant;

}c1;

void depot(float m){

c1.montant +=m;//c1.montant =c1.montant+m;

}

void retrait(float m){

if(c1.montant>=m) c1.montant -=m;//c1.montant =c1.montant -=m-m

else printf("solde insuffisant ..!!");

}

main(){

 

int choix;

float somme;

printf("entrer le nom:"); scanf("%s",c1.nom);

printf("entrer le num:"); scanf("%d",&c1.num);

c1.montant=0;

do{

printf("La somme:%gn",c1.montant);

printf("1 : DEPOSERn2 : RETIRERn0 : SORTIRnENTRER VOTRE CHOIX");

scanf("%d",&choix);

printf("entrer la somme à diposer/retirer:");

scanf("%f",&somme);

 

 

 

switch(choix){

case  1: depot(somme); break;

case  2:retrait(somme); break;

}

 

 

 

}while(choix!=0);

system("pause");

}

 

structure etudiant

//Télécharger : http://zipansion.com/HELT

#include<stdio.h>

#include<stdlib.h>

struct etudiant {

char matier[20] ;

char nom[20] ;

int  note[4] ;

float moyenne ;

}  ;

 

void lecture(etudiant* t, int x)

{

 

int i,j;

float M,S=0;

// x etudiants boucle j , i=4 notes boucle i

printf("%dnn",x);

for( j=0 ; j<x ; j++)

{

printf("Donner le nom d'etudiant: ") ;

scanf("%s" , t[j].nom) ;

 

printf("Donner ses notes <entre 0 et 20>n: ") ;

S=0;

for( i=0 ; i<4 ; i++)

{

do{

printf("  saisir note numero  %d :",i);

scanf("%d" ,&t[j].note[i]) ;

if (t[j].note[i]>20 || t[j].note[i]<0) printf("erreur saisir note >=0 et <=20n");

}while(t[j].note[i]>20 || t[j].note[i]<0);

S=S+t[j].note[i];

 

}

 

t[j].moyenne=S/4;

 

printf("Moyenne : %0.2f n",t[j].moyenne) ;

}

}

 

void affichage(etudiant* t,int x)

{int j;

printf("%dnn",x);

for( j=0 ; j<x ; j++) {

printf("Nom : %s t",t[j].nom) ;

printf("Moyenne : %0.2f n",t[j].moyenne) ;

 

}

 

}

 

main()

{

etudiant    t[20] ;

int i,n ;

printf("Donner le nombre d'etudiants : ") ;

scanf("%d",&n) ;

lecture(t,n) ; //saisi etudiant

 

affichage(t,n)  ;

 

 

system("pause");

}

structure article

//Télécharger : http://zipansion.com/HES9

#include<stdio.h>

#include<stdlib.h>

 

typedef struct article

{

int id;

float prixbrut;

float tva;

int quantite;

}art;

 

 

void affiche(art a)

{

printf("prix=%f n tva=%f nquantite=%d n",a.prixbrut,a.tva,a.quantite);

}

 

float prix(art a)

{

return a.prixbrut*(1+a.tva);

}

 

void saisie(art *a)

{

printf("donner id:n");

scanf("%d",&a->id);

printf("donner prix:n");

scanf("%f",&a->prixbrut);

printf("donner tva:n");

scanf("%f",&a->tva);

printf("donner quantite:n");

scanf("%d",&a->quantite);

}

 

 

int main()

{

art a;

saisie(&a);

affiche(a);

 

system("pause");

return 0;

}

Structure point avec pointeur

//Télécharger : http://zipansion.com/HEWv

#include<stdio.h>

#include<stdlib.h>

struct point{ int x,y; };

void saisi(point *p,int n)

{int i;

for(i=0;i<n;i++){

printf("donner x ");scanf("%d",&p[i].x);

printf("donner y "); scanf("%d",&p[i].y);

}

}

void affichage(point *p,int n)

{int i;

for(i=0;i<n;i++){

 

printf("(%d,%d)n",p[i].x,p[i].y);

}

}

 

void somme2(point *p1,int n)//p1+p2

{int i,sx=0,sy=0;

for (i=0;i<n;i++){

sx+=p1[i].x;

sy+=p1[i].y;

}

p1[n-1].x=sx;

p1[n-1].y=sy;

 

}

 

int main()

{point *p1=NULL;

int n;

printf("donner n ");scanf("%d",&n);

p1=(point*)malloc(sizeof(point)*n);

saisi(p1,n);

somme2(p1,n);

affichage(p1,n);

 

system("pause");

}

 

structure étudiant avec fichier

//Télécharger : http://zipansion.com/HEca

#include<stdio.h>

#include<stdlib.h>

struct Etudiant{

int id;

char nom[20];

float note[2];

};

int main()

{Etudiant e;

int i;

char NOM_FICH[] = "etudiant.txt";

FILE *FICHIER;

//saisi

printf("donner id ");scanf("%d",&e.id);

printf("donner nom ");scanf("%s",e.nom);

for(i=0;i<2;i++){

printf("donner note %d :",i+1);scanf("%f",&e.note[i]);

}

//affich

printf("%dt%st",e.id,e.nom);

for(i=0;i<2;i++){

printf("%0.2ft",e.note[i]);

}

printf("n");

/* Ouverture du nouveau fichier en écriture */

FICHIER = fopen(NOM_FICH, "w");

if (!FICHIER)

{

printf("aERREUR: Impossible d'ouvrir "

"le fichier: %s.n", NOM_FICH);

exit(-1);

}

fprintf(FICHIER, "%dt%st%ft%fn", e.id, e.nom, e.note[0], e.note[1]);

/* Fermeture du fichier */

fclose(FICHIER);

/* Ouverture du fichier en lecture */

FICHIER = fopen(NOM_FICH, "r");

if (!FICHIER)

{

printf("aERREUR: Impossible d'ouvrir "

"le fichier: %s.n", NOM_FICH);

exit(-1);

}

/* Affichage du fichier */

printf("*** Contenu du fichier  %s ***n", NOM_FICH);

while (!feof(FICHIER))

{

fscanf(FICHIER, "%dt%st%ft%fn", &e.id, e.nom, &e.note[0], &e.note[1]);

printf("id : %dt", e.id);

printf("nom : %st ", e.nom);

printf("y : %ft ", e.note[0]);

printf("z : %f", e.note[1]);

printf("n");

 

}

/* Fermeture du fichier */

fclose(FICHIER);

system("pause");

}

 

Calculer et copier chaine de caractère

//Télécharger : http://zipansion.com/HEhK

#include<stdio.h>

#include<stdlib.h>

int longueur(char nom[])///strlen

{int i=0;

while (nom[i]!='')

{i++;

}

return i;

}

void copie(char c1[],char c2[])//strcpy

{int i=0;

while(c1[i]!='')

{

c2[i]=c1[i];

i++;

}

c2[i]='';

}

void copie1(char c1[],char c2[])//strcpy

{int i;

for (i=0;i<longueur(c1);i++){

c2[i]=c1[i];

}

c2[i]='';

}

int main()

{int i=0;

char nom[]="safi";

char NOM[20];

char NOM1[20];

printf("%s t %dn",nom,longueur(nom));

copie(nom,NOM);

printf("%s t %dn",NOM,longueur(NOM));

copie1(nom,NOM1);

printf("%s t %dn",NOM1,longueur(NOM1));

system("pause");

}

 

armstrong (avec décomposition du nombre )

//Télécharger : http://zipansion.com/HExR

//armstrong

#include <stdio.h>

#include <stdlib.h>

int puiss(int x, int y)

{if (y==0) return 1;

else return x*puiss(x,y-1);

 

}

main()

{int n,nn,t[10],i=0,j,s=0;

printf("donner un nombre:");

scanf("%d",&n);

nn=n;

do {

t[i]=n%10;

n=n/10;

 

i++;

 

}

while (n!=0);

 

printf("   nbre caract %dn",i);

for (j=0;j<i;j++)printf(" %d   %dn",j,t[j]);

 

for (j=0;j<i;j++)

{ s+=puiss(t[j],i);

printf("t=%d  i=%d    s=%dn",t[j],i,s);

}

printf("nn");

printf("    %dn",s);

if (s==nn){

printf("    %d est armstrongn",nn);

}

else {

printf("    %d est non armstrongn",nn);

}

system("pause");

 

}

Inverser chaine

//Télécharger : http://zipansion.com/HF23

#include <stdio.h>

#include <stdlib.h>

int longChaine(char *ch)//strlen

{int i=0;

while(ch[i]!='')i++;

return i;

}

 

void Inverser(char*ch1,char *ch2)

{int i=0;

int n;

n=longChaine(ch1);

while(ch1[i]!=''){

ch2[i]=ch1[n-i-1];

i++;

}

}

int main () {

 

char CH1[100],CH2[100];

 

printf("Entrez la chaine a inverser : ");

//gets ==scanf

//put //pritnt

gets(CH1); puts(CH1);

Inverser(CH1,CH2);

puts(CH2);

system("pause");

return 0;

}

Conjugaison d'un verbe du premier groupe

//Télécharger : http://zipansion.com/HF7E

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include<conio.h>

int main()

{

char STR1[6][6]={"je ","tu ","il ","nous ","vous ","ils "};

char STR2[6][4]={"e","es","e","ons","ez","ent"};

char VERB[20];

char AFFI[30];

int L,i,x;

printf("Verbe : ");

gets(VERB); //scanf

L=strlen(VERB);

if ((VERB[L-2]!='e') || (VERB[L-1]!='r'))

puts("aCe n'est pas un verbe du premier groupe.!");//printf

else

{

/* Couper la terminaison 'er'. */

VERB[L-2]='';

/* Conjuguer ... */

 

for(i=0;i<6;i++){

AFFI[0]='';

strcat(AFFI, STR1[i]);

strcat(AFFI, VERB);

strcat(AFFI, STR2[i]);

// printf("%s n",AFFI);

puts(AFFI);

 

}

 

 

}

 

 

getch();

system("pause");

getch();

system("pause");

return 0;

}

Longueur chaine (autre méthode)

//Télécharger : http://zipansion.com/HFDm

#include <stdio.h>

#include<conio.h>

 

int longChaine(char *ch)//strlen

{int i=0;

while(ch[i]!='')i++;

return i;

}

int longChaine1(char *ch)

{int i;

 

for(i=0;ch[i]!='';i++);

 

return i;

}

 

int  main(){

char Chaine[20+1];

char Chaine1[20+1]={ 'B', 'o', 'n', 'j', 'o', 'u', 'r', '' };

 

Chaine[0]= 'B';

 

Chaine[1]= 'o';

 

Chaine[2]= 'n';

 

Chaine[3]= 'j';

 

Chaine[4]= 'o';

 

Chaine[5]= 'u';

 

Chaine[6]= 'r';

 

Chaine[7]= '';

printf("chaine %s   %dn",Chaine,longChaine(Chaine));

printf("chaine1 %s   %dn",Chaine1,longChaine1(Chaine1));

getch();

 

}

 

compter le nombre de caractère d'un mot

//Télécharger : http://zipansion.com/HFKM

#include <stdio.h>

#include <stdlib.h>

#include<string.h>

 

int main()

{

char s[]="bbojjouuuur";

char c[20],dig[3];

int i=0,n,j=0;

while (s[i]!='')

{ n=1;

while ((s[i]!='')&& (s[i]==s[i+1])){

i++;n++;

printf("%c %d  %d n",s[i],i,n);

}

 

if(s[i]!=''){

c[j]=s[i];

//char dig = (char)(((int)'0')+n);

itoa (n,dig,10);

c[j+1]=dig[0];

j=j+2;

}

 

 

 

i++;

 

}

c[j]='';

printf("c=  %s n",c);

system("pause");

return 0;

}

permuter chaine et convertir en majuscule

//Télécharger : http://zipansion.com/HFOh

#include <stdio.h>

#include <stdlib.h>

void permuter(char *c1,char *c2)

{char t;

t=*c1;*c1=*c2;*c2=t;

}

char  majuscule(char c)

{if((c>=97) && (c<=122)) return (c-32);// a-->97   A-->65

else return c;

}

 

char *majCh(char*ch)

{int i=0;

while(ch[i]!=''){

ch[i]=majuscule(ch[i]);

i++;

}

return ch;

}

 

int main () {

char c,cc1='a',cc2='b';

char CH[100];

c=  getchar();//scanf un caractere

printf("%cn",majuscule(c));

fflush(stdin);

printf("Entrez la chaine à convertir : ");

gets(CH);//scanf

majCh(CH);

puts(CH);//printf

permuter(&cc1,&cc2);

printf("%c  %c  n",cc1,cc2);

system("pause");

return 0;

}

Copier et concaténer chaine

//Télécharger : http://zipansion.com/HFRp

#include <stdio.h>

#include <stdlib.h>

#include<string.h>

char *copieString (const char *str)

{

char *str2=new char(strlen(str)+1); strcpy(str2,str);  printf("%st%sn",str,str2);  return str2;

}

char *LireText(void)

{   char chaine[81]="Hello world"; char *str = new char[strlen(chaine+1)];  strcpy(str,chaine);return str ;

}

char *cancat(char *c1,char *c2)

{int n1,n2,i=0;

char *z;

n1=strlen(c1);n2=strlen(c2);z=(char*)malloc(sizeof(char)*(n1+n2));

while(c1[i]!=''){z[i]=c1[i];i++;}

i=0;while(c2[i]!=''){z[i+n1]=c2[i];i++;}

return z;

}

int main ()

{    char *p,*d;

char a[]="abc";char b[]="def";char *c;

c=(char*)malloc(sizeof(char)*(strlen(a)+strlen(b)));

p=LireText();   printf("p=%sn",p);

d= copieString (p);printf("d=%sn",d);

c=cancat(a,b);

delete []p;

p=NULL;

system("PAUSE");

}

Liste chainée -1-

//Télécharger : http://zipansion.com/HFX4

#include<stdio.h>

#include<stdlib.h>

struct etudiant{

int num;

char nom[20];

etudiant *psuiv;

};

 

main()

{

etudiant *e1,*e2,*e3,*e4;

etudiant *list;

list=NULL;

e1=(etudiant*)malloc(sizeof(etudiant));

printf("donner num ");scanf("%d",&e1->num);

printf("donner nom ");scanf("%s",e1->nom);

e1->psuiv=NULL;

list=e1;

 

e2=(etudiant*)malloc(sizeof(etudiant));

printf("donner num ");scanf("%d",&e2->num);

printf("donner nom ");scanf("%s",e2->nom);

e2->psuiv=list;

list=e2;

 

e3=(etudiant*)malloc(sizeof(etudiant));

printf("donner num ");scanf("%d",&e3->num);

printf("donner nom ");scanf("%s",e3->nom);

e3->psuiv=list;

list=e3;

 

 

e4=(etudiant*)malloc(sizeof(etudiant));

printf("donner num ");scanf("%d",&e4->num);

printf("donner nom ");scanf("%s",e4->nom);

e4->psuiv=list;

list=e4;

//lecture liste chainee

 

etudiant* tmp;

tmp=list;

printf("Affichage Tout etudiant :n");

if(tmp==NULL){

printf("acune liste viden");

}

while(tmp!=NULL){

printf("@tmp %pt %p t num %d t %s n ",tmp,tmp->psuiv,tmp->num,tmp->nom);

 

tmp=tmp->psuiv;

}

 

 

 

 

 

 

 

system("pause");

 

}

Liste chainée -2-

//Télécharger : http://zipansion.com/HFce

#include<stdio.h>

#include<stdlib.h>

#include<conio.h>//produit* nv= new produit;

#include<string.h>

typedef struct element{

int value;

char nom[20];

struct  element* suivant;

}element;

typedef struct liste{

int nbElm;

element *tete;

element *queue;

}liste;

//cree liste

liste *creer_list(){

liste* lst=(liste*)malloc(sizeof(liste));

lst->tete=NULL;

lst->queue=NULL;

lst->nbElm=0;

return lst;

}

void ajouter_en_tete(liste *lst,int valeur,char nom[])

{

element *e=(element*)malloc(sizeof(element));

e->value=valeur;

strcpy(e->nom,nom);

e->suivant=lst->tete;

lst->tete=e;

if(lst->queue==NULL)lst->queue=e;

lst->nbElm++;

 

}

void ajouter_en_queue(liste *lst,int valeur,char nom[])

{

element *e=(element*)malloc(sizeof(element));

element *tmp=(element*)malloc(sizeof(element));

e->value=valeur;

strcpy(e->nom,nom);

e->suivant=NULL;

if(lst->tete==NULL)lst->tete=e;

if (lst->queue!=NULL)lst->queue->suivant=e;

lst->queue=e;

lst->nbElm++;

}

int supprimer_tete(liste *lst)

{

element *p=lst->tete;

int res=p->value;

lst->tete=p->suivant;

lst->nbElm--;

free(p);

return res;

 

 

}

main(){

liste* list=NULL;

element * E=NULL;

int valeur;

char nom[4];

//list=NULL;

list= creer_list();

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

 

printf("donner nom");

scanf("%s",&nom);

valeur=4;

ajouter_en_tete(list, valeur,nom);

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

 

printf("donner nom");

scanf("%s",&nom);

valeur=40;

ajouter_en_tete(list, valeur,nom);

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

 

printf("donner nom");

scanf("%s",&nom);

valeur=400;

ajouter_en_tete(list, valeur,nom);

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

printf("Queue1 donner nom");

scanf("%s",&nom);

valeur=4000;

ajouter_en_queue(list, valeur,nom);

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

printf("Queue2 donner nom");

scanf("%s",&nom);

valeur=40000;

ajouter_en_queue(list, valeur,nom);

printf("pour savoir adrsse de debut de list; %d   %d   %d   %dnnn",list,list->tete,list->queue,list->nbElm);

 

//LECTURE DE LA LISTE

element* tmp;

 

tmp=list->tete;

printf("adresse tmp  %d : n",tmp);

if(tmp==NULL){

printf("acune liste a afficher ajoutez unen");

}

while(tmp!=NULL){

printf("  @tmp %d : ref %d    nom %sn",tmp,tmp->value,tmp->nom);

tmp=tmp->suivant;

 

}

printf("%dn",supprimer_tete(list));

 

 

 

tmp=list->tete;

printf("adresse tmp  %d : n",tmp);

if(tmp==NULL){

printf("acune liste a afficher ajoutez unen");

}

while(tmp!=NULL){

printf("  @tmp %d : ref %d    nom %sn",tmp,tmp->value,tmp->nom);

tmp=tmp->suivant;

 

}

system("pause");

}

Liste chainée -3-

//Télécharger : http://zipansion.com/HFjU

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

 

int n;//n est le nombre des notes pour chaque etudiant-variable globale-

struct date

{

int jj;

int mm;

int aa;

};

 

typedef struct date DATE;

 

struct etudiant

{

int matricule;

char nom[20];

char prenom[20];

DATE date_naiss;

float tab_note[10];

float moyenne;

};

 

typedef struct etudiant ETUDIANT;

struct Element

{

ETUDIANT info;

struct Element *suiv;

};

typedef struct Element *liste;

 

int controle_date(int a,int b,int c)

{

int mois[12];

mois[0]=31;

mois[8]=30;

mois[2]=31;

mois[4]=31;

mois[6]=31;

mois[7]=31;

mois[9]=31;

mois[11]=31;

mois[3]=30;

mois[10]=30;

mois[1]=30;

mois[5]=30;

if(c%4==0)

mois[1]=29;

else

mois[1]=28;

if((b-1<0)||(b-1>11))

return(0);

if ((a>mois[b+1])||(a<1))

return(0);

return(1);

}

 

float remplir(float t[20])

{

float moyn=0;

do

{

printf("nentrer le nombre des notes qui doit etre superieur ou egale a 1n");

scanf("%d",&n);

}

while(n<1);

for(int i=0;i<n;i++)

{

printf("nentrer la note de la martiere -%d-n",i);

scanf("%f",&t[i]);

moyn=moyn+t[i];

}

moyn=moyn/n;

return(moyn);

}

 

void saisie_etudiant(ETUDIANT *etud)

{

do

{

printf("entrer le numero de la matricule qui doit etre >0n");

scanf("%d",&(*etud).matricule);

}

while(etud->matricule<=0);

printf("nentrer le nomn");

scanf("%s",etud->nom);

printf("nentrer le prenomn");

scanf("%s",etud->prenom);

do

{

printf("nentrer la jour de la date de naissancen");

scanf("%d",&(*etud).date_naiss.jj);

printf("nentrer le mois de la date de naissancen");

scanf("%d",&(*etud).date_naiss.mm);

printf("nentrer l'anné de la date de naissancen");

scanf("%d",&(*etud).date_naiss.aa);

}

while(controle_date(etud->date_naiss.jj,etud->date_naiss.mm,etud->date_naiss.aa)<0);

etud->moyenne=remplir(etud->tab_note);

}

 

void affiche_etudiant(ETUDIANT etud)

{

printf("nla matricule est :n");

printf("%d",etud.matricule);

printf("nle nom est :n");

printf("%s",etud.nom);

printf("nle prenom est :n");

printf("%s",etud.prenom);

printf("nla date de naissance est :n");

printf("nle jour est :%d",etud.date_naiss.jj);

printf("n le mois est :%d",etud.date_naiss.mm);

printf("n l'anne est :%d",etud.date_naiss.aa);

printf("nles notes sont :n");

for(int i=0;i<n;i++)

printf("la note de la matiere -%d-est %fn",i,etud.tab_note[i]);

printf("nla moyenne est :n");

printf("%f",etud.moyenne);

}

 

//creer liste

liste creer_liste()//creer une liste consiste a metre la tete a NULL

{

return(NULL);

}

 

// ajouter un element au debut de la liste

liste ajout_debut(liste tete)

{

//allouer(p);

liste p;

p=(liste)malloc(sizeof(liste));

//remplissage de p

saisie_etudiant(&(p->info));

//chainage

p->suiv=tete;

return(p);

}

 

//ajouter a la fin de la liste

liste ajout_fin(liste tete)

{

//allouer(p);

liste p,pp,ps;

ps=tete;

pp=NULL;

//pp va pointer sur l'element l'avant dernier

while(ps!=NULL)//rechercher du dernier element

{

pp=ps;

ps=ps->suiv;

}

//allocation de p

p=(liste)malloc(sizeof(liste));

//remplissage de p

saisie_etudiant(&(p->info));

//chainage

p->suiv=NULL;

if (pp==NULL)//si pp=NULL alors que la liste est initialement vide,l'ajout va etre eeffectue au debut de la liste

return (p);//on retourne alors p qui sera parsuite la tete de la liste

else

pp->suiv=p;

return(tete);

}

 

//recherche d'un element dans la liste

int recherche(liste tete)

{

liste p;

p=tete;

int cherch;

do

{

printf("entrer une matricule matricule non nulle de l'etudiant a rechercher");

scanf("%d",&cherch);

}

while(cherch<1);

while((p->info.matricule!=cherch)&&(p!=NULL))//recherche du mot dans la liste

p=p->suiv;

if(p==NULL)

//si pp=NULL alors que le mot cle n'existe pas

return(-1);

return(0);

}

 

 

//tri de la liste (tri alphabetique)

liste precedent(liste p,int m)//cette fonction cherche le precedent grace a une matricule donné

{

liste pp,ps;

ps=p;

pp=NULL;

while((ps!=NULL)&&(ps->info.matricule<m))

{

pp=ps;

ps=ps->suiv;

}

return(pp);

}

 

liste insertion(liste ord,liste p)//cette fonction insert un étudiant dans sa bonne position afin de garder la nuvelle liste trier

{

liste prec;

prec=precedent(ord,p->info.matricule) ;

if (prec==NULL)

{

p->suiv=ord;

ord=p;

}

else

{

p->suiv=prec->suiv;

prec->suiv=p;

}

return(ord);

 

}

 

liste tri_insertion_chaine(liste tete)//tri de la liste

{

liste p,aux,ord;

ord=NULL;

aux=tete;

while (aux!=NULL)

{

p=aux;

aux=aux->suiv;

ord=insertion(ord,p);

}

return(ord);

}

 

//tri de la liste (tri numerique)

liste precedent2(liste p,float m)

{

liste pp,ps;

ps=p;

pp=NULL;

while((ps!=NULL)&&(ps->info.moyenne<m))

{

pp=ps;

ps=ps->suiv;

}

return(pp);

}

 

liste insertion2(liste ord,liste p)

{

liste prec;

prec=precedent2(ord,p->info.moyenne) ;

if (prec==NULL)

{

p->suiv=ord;

ord=p;

}

else

{

p->suiv=prec->suiv;

prec->suiv=p;

}

return(ord);

 

}

liste tri_insertion_numerique(liste tete)//cette tri est comme la tri precedante mais son critere de tri est la moyenne

{

liste p,aux,ord;

ord=NULL;

aux=tete;

while (aux!=NULL)

{

p=aux;

aux=aux->suiv;

ord=insertion2(ord,p);

}

return(ord);

}

 

//affichage des etudiant qui ont le meme nom

liste r_list_nom(liste tete)

{

liste p,ps,psave;

p=tri_insertion_chaine(tete);//tout d'abord on effectue une tri sur la liste

psave=p;//apres la tri de la liste on aura besoin d'une variable auxiliaire qui va garder la nouvelle tete de la liste et qui sera la valeur de retour de la fonction

int i=1;

printf("la %d eme ensemble des etudiant qui ont le meme noms :n",i);//on affiche la premiere ensemble

printf("%dn",p->info.matricule);

ps=p;

p=p->suiv;

while (p!=NULL)

{

if(p->info.matricule!=ps->info.matricule)//dans le cas ou deux elements consecutive sont differents cela signifie qu'il ya une nouvelle ensemble

{

i++;

printf("la %d eme ensemble des etudiant qui ont le meme noms :n",i);

}

printf("%dn",p->info.matricule);

p=p->suiv;

}

return(psave);

}

 

//tri de la liste (tri numerique par jour de naissance)

liste precedent3(liste p,int j,int m,int a)

{

int ok=1;

liste pp,ps;

ps=p;

pp=NULL;

while((ps!=NULL)&&(ok))

{

if ((ps->info.date_naiss.aa*400+ps->info.date_naiss.mm*20+ps->info.date_naiss.jj)<(a*400+m*20+j))//comparaison de deux date

{

pp=ps;

ps=ps->suiv;

}

else

ok=0;

}

return(pp);

}

 

liste insertion3(liste ord,liste p)

{

liste prec;

prec=precedent3(ord,p->info.date_naiss.jj,p->info.date_naiss.mm,p->info.date_naiss.aa) ;

if (prec==NULL)

{

p->suiv=ord;

ord=p;

}

else

{

p->suiv=prec->suiv;

prec->suiv=p;

}

return(ord);

 

}

liste tri_insertion_jour(liste tete)//cette tri est comme la tri precedante mais son critere de tri est la moyenne

{

liste p,aux,ord;

ord=NULL;

aux=tete;

while (aux!=NULL)

{

p=aux;

aux=aux->suiv;

ord=insertion3(ord,p);

}

return(ord);

}

 

//affichage des etudiants qui sont nes le meme jour

liste r_list_date(liste tete)

{

liste p,ps,psave;

p=tri_insertion_jour(tete);//tout d'abord on fait une tri par jour de naissance

psave=p;//apres la tri de la liste on aura besoin d'une variable auxiliaire qui va garder la nouvelle tete de la liste et qui sera la valeur de retour de la fonction

int i=1;

printf("la %d eme ensemble des etudiants qui sont nes le meme jour :n",i);//On affiche la premiere ensemble en dehord de la boucle

printf("%dn",p->info.matricule);

ps=p;

p=p->suiv;

while (p!=NULL)

{

if((p->info.date_naiss.jj!=ps->info.date_naiss.jj)||(p->info.date_naiss.mm!=ps->info.date_naiss.mm)||(p->info.date_naiss.aa!=ps->info.date_naiss.aa))//à chaque fois qu'on trouve deux elements conséqutive qui sont differents cela signifie qu'il ya une nouvelle ensemble

{

i++;

printf("la %d eme ensemble des etudiants qui sont nes le meme jour est:n",i);

}

printf("%dn",p->info.matricule);

p=p->suiv;

}

return(psave);

}

 

//suppression

liste supprimer(liste tete)

{

liste pp,ps;//le pointeur ps va pointer sur l'element a supprimer

int cherch;

do

{

puts("entrer une matricule non nulle de l'etudiant a supprimern");

scanf("%d",&cherch);

}

while (cherch<1);

pp=precedent(tete,cherch);//chercher le precedent de l'element à supprimer

if (pp==NULL)//Dans ce cas l'element a supprimer est la tete de la liste

ps=tete;

else

ps=pp->suiv;

if(ps==NULL)

{

printf("l'element que vous avez entrer n'existe pas dans la liste n suppression non effectue");

return(tete);

}

if (pp==NULL)

tete=tete->suiv;

else

pp->suiv=ps->suiv;

delete ps;

printf("suppression effectue");

return(tete);

}

 

//affichage de la liste

void afficher(liste tete)

{

printf("la liste est nn");

liste p;

p=tete;

do

{

affiche_etudiant(p->info);

p=p->suiv;

}

while(p!=NULL);

}

 

main()

{

 

liste tete;

tete=creer_liste();

int rep;

do

{

printf("nn");

printf(" ________________________________________________________________________n|n");

printf("| GEStIONAIRE ETUDIANT |n");

printf("|________________________________________________________________________|n|n");

printf("| 1-ajouter un element au debut de la liste |n");

printf("| 2-ajouter un element a la fin de la liste |n");

printf("| 3-rechercher un etudiant dans la liste |n");

printf("| 4-l'ensemble des etuidants qui portent le meme le meme nom |n");

printf("| 5-l'ensemble des etuidants qui sont nes le meme jour |n");

printf("| 6-trier les etudiants alphabetiquement |n");

printf("| 7-trier les etudiants par moyenne |n");

printf("| 8-trier les etudiants par jour de naissance |n");

printf("| 9-supprimer un element de la liste |n");

printf("| 10-Affichage de la liste |n");

printf("| 0-QUITTER |n");

printf("|________________________________________________________________________|n");

printf("| donner le numero de votre choix |n");

printf("|________________________________________________________________________|nn");

scanf("%d",&rep);

switch(rep)

{

case 1:tete=ajout_debut(tete);

break;

case 2:tete=ajout_fin(tete);

break;

case 3: if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

{

if (recherche(tete)==0)

printf("etudiant trouve");

else

printf("etudiant non trouve");

}

break;

case 4:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

tete=r_list_nom(tete);

break;

case 5:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

tete=r_list_date(tete);

break;

case 6: if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

{

tete=tri_insertion_chaine(tete);

printf("tri effectue");

}

break;

case 7:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

{

tete=tri_insertion_numerique(tete);

printf("tri effectue");

}

break;

case 8:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

{

tete=tri_insertion_jour(tete);

printf("tri effectue");

}

break;

case 9:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

tete=supprimer(tete);

break;

case 10:if (tete==NULL)

printf("la liste est vide vous devez la remplir");

else

afficher(tete);

break;

}

}

while(rep!=0);

 

getch();

}

Polynome

//Télécharger : http://zipansion.com/HFo9

#include <stdio.h>

#include <stdlib.h>

 

typedef struct poly {

int degr;

int fac;

struct poly* nxt;

}poly;

 

 

poly* ajout (poly* P){

poly* nv=(poly*)malloc(sizeof(poly));

printf ("donnez la degre : ");

scanf ("%d", &nv->degr);

printf ("donnez le coificiant : ");

scanf ("%d", &nv->fac);

nv->nxt=P;

return nv;

}

void affichage (poly* P){

poly* pc=P;

while (pc != NULL){

if (pc->degr > 1)

printf ("%dx^%d", pc->fac, pc->degr);

if (pc->degr == 1)

printf ("%dx", pc->fac);

if (pc->degr==0)

printf ("%d", pc->fac);

if (pc->nxt != NULL)

printf ("+");

pc=pc->nxt;

}

}

poly* inverse (poly* list){

poly *p, *q, *r;

q=list->nxt;

list->nxt=NULL;

r=q->nxt;

q->nxt=list;

while (r != NULL){

p=q;

q=r;

r=r->nxt;

q->nxt=p;

 

}

list=q;

return list;

}

 

int puissance (int P, int x){

int i;

if (x==0)

return 1;

for (i=0;i<P;i++)

x*=x;

return x;

}

 

poly* derive (poly* P){

poly* drv=NULL;

poly* pc,*nv;

pc=P;

while (pc != NULL ){

if (pc->degr != 0){

nv=(poly*)malloc(sizeof( poly));

nv->fac=pc->degr*pc->fac;

nv->degr=pc->degr-1;

nv->nxt=drv;

drv=nv;

}

pc=pc->nxt;

 

}

return drv;

}

poly* ajouter (poly *p,poly *l){

poly *pc=p, *lc=l;

poly *S=NULL;

poly *nv;

while(pc != NULL && lc != NULL){

nv=(poly*)malloc(sizeof(poly));

if (pc->degr==lc->degr){

nv->degr=pc->degr;

nv->fac=pc->fac+lc->fac;

nv->nxt=S;

S=nv;

pc=pc->nxt;

lc=lc->nxt;

}

if (pc->degr > lc->degr){

nv->degr=pc->degr;

nv->fac=pc->fac;

nv->nxt=S;

S=nv;

pc=pc->nxt;

}

if (lc->degr > pc->degr){

nv->degr=lc->degr;

nv->fac=lc->fac;

nv->nxt=S;

S=nv;

lc=lc->nxt;

}

}

nv=(poly*)malloc(sizeof(poly));

if (pc != NULL){

nv=pc;

nv->nxt=S;

S=nv;

}

if (lc != NULL){

nv=lc;

nv->nxt=S;

S=nv;

}

 

return S;

}

 

 

 

int main(){

int n, i, X, puis, z;

poly* P1=NULL;

poly* D1=NULL;

poly* pc, *P2=NULL;

poly* Somme=NULL;

printf ("donnez le nombre des monome : ");

scanf ("%d", &n);

for (i=0; i<n; i++){

P1=ajout(P1);

}

 

P1=inverse (P1);

affichage (P1);

printf ("n");

printf ("donnez un X : ");

scanf ("%d", &X);

puis=0;

pc=P1;

while (pc != NULL ){

puis+=(puissance(pc->degr, X)*(pc->fac));

pc=pc->nxt;

}

 

printf ("la valeur de X par P1 est : %d ", puis);

printf ("n");

D1=derive (P1);

D1=inverse(D1);

affichage(D1);

printf ("n");

printf ("donnez le nombre des monome : ");

scanf ("%d", &z);

for (i=0; i<z; i++){

P1=ajout(P2);

}

 

P1=inverse (P2);

affichage (P2);

Somme=ajouter(P1, P2);

P1=inverse (Somme);

affichage (Somme);

 

return 0;

 

 

}

 

 

 

 

 

 

 

Pile et File

//Télécharger : http://zipansion.com/HFvf

//File.h

#ifndef FILE_H_

#define FILE_H_

 

 

typedef int element;

struct file

{

element valeur;

struct file * suivant;

};

typedef struct file file, * File;

 

#endif

////////////////////////////////////////////////////////////////////////////////////////

//FileFonc.c

# include <stdlib.h>

# include <stdio.h>

# include "File.h"

 

File enfiler(element val, File f)

{

File fn;

fn=malloc(sizeof(file));

fn->valeur=val;

fn->suivant=f;

return fn;

}

 

int testerFileVide(File f)

{

return f==NULL;

}

 

File defiler(File f)

{

File pfile1, pfile2;

if(f==NULL)

return NULL;

if(f->suivant==NULL)

{

free(f);

return NULL;

}

pfile1=f;

while(pfile1->suivant->suivant!=NULL)

pfile1=pfile1->suivant;

pfile2=pfile1->suivant;

pfile1->suivant=NULL;

free(pfile2);

return f;

}

 

int valeurTete(File *f)

{

int vdef;

File pfile1, pfile2;

if((*f)->suivant==NULL)

{

vdef=(*f)->valeur;

free(*f);

return vdef;

}

pfile1=*f;

while(pfile1->suivant->suivant!=NULL)

pfile1=pfile1->suivant;

pfile2=pfile1->suivant;

pfile1->suivant=NULL;

vdef=pfile2->valeur;

free(pfile2);

return vdef;

}

 

element queueFile(File f)

{

return f->valeur;

}

 

element teteFile(File f)

{

while(f->suivant!=NULL)

f=f->suivant;

return f->valeur;

}

 

File viderFile(File f)

{

while(f!=NULL)

f=defiler(f);

return f;

}

 

void Afficher(File f)

{

printf("ttt");

while(f!=NULL)

{

printf("%d->",f->valeur);

f=f->suivant;

}

printf("NULLn");

}

///////////////////////////////////////////////////////////////////////////////////

File.c

# include <stdlib.h>

# include <stdio.h>

# include "FileFonc.c"

 

main()

{

File l=NULL;

int choix;

int v,d;

do {

printf("nntttMENUnttt1----- Affichernttt2----- Emfilernttt3----- Defilernttt4----- Le QueueFilenttt5----- La TeteFilenttt6----- TestVidenttt7----- Vidernttt8----- Exitn");

 

printf("ttt---------------------nn ");

printf("tttDonner Votre Choix : ");scanf("%d",&choix);

switch(choix)

{

case 1:Afficher(l);break;

case 2:printf("ttt");printf("Donner La Valeur : ");scanf("%d",&v);l=enfiler(v,l);break;

case 3:printf("ttt");d=valeurTete(&l);printf("La Valeur Defiler : %dn",d);break;

case 4:printf("ttt");d=queueFile(l);printf("Le Sommet : %dn",d);break;

case 5:printf("ttt");d=teteFile(l);printf("Le Sommet : %dn",d);break;

case 6:if(testerFileVide(l)) printf("tttViden");else printf("tttNonViden"); break;

case 7:l=viderFile(l);Afficher(l);break;

case 8:printf("ttt");printf("BYn");break;

default:printf("----n");break;

}

 

}while(choix!=8);

}

 

Arbre Binaire

//Télécharger : http://zipansion.com/HG0R

//arbre.h

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<math.h>

 

//#include"pile.h"

 

 

typedef int element;

struct noeud

{

element valeur;

struct noeud * filsG;

struct noeud * filsD;

};

typedef struct noeud noeud, * arbreB;

 

 

//************************* La Creation Du Noeud ***********************************

 

 

arbreB creeNoeud(element val,arbreB fg, arbreB fd)

{

arbreB a=malloc(sizeof(noeud));

a->valeur=val;

a->filsG=fg;

a->filsD=fd;

return a;

}

 

//************************** Ajouter Element A Gauche ********************************

 

arbreB ajouterGElementArbreB(arbreB a, element val)

{

if(a==NULL)

a=creeNoeud(val,NULL,NULL);

else

if(a->filsG==NULL)

a->filsG=creeNoeud(val,NULL,NULL);

else

if(a->filsD==NULL)

a->filsD=creeNoeud(val,NULL,NULL);

else

a->filsG=ajouterGElementArbreB(a->filsG, val);

return a;

}

 

//************************** Ajouter Element A Gauche ********************************

 

 

arbreB ajouterDElementArbreB(arbreB a, element val)

{

if(a==NULL)

a=creeNoeud(val,NULL,NULL);

else

if(a->filsG==NULL)

a->filsG=creeNoeud(val,NULL,NULL);

else

if(a->filsD==NULL)

a->filsD=creeNoeud(val,NULL,NULL);

else

a->filsD=ajouterDElementArbreB(a->filsG, val);

return a;

}

 

//*********************Creation d une arbre binaire de recherche **********************

 

 

//==================>  ajouter un elt dans un arbre de recherche

//*************ajout

 

arbreB  ajoutArbreBRecherche( element val, arbreB a)

{

if(a==NULL)

a=creeNoeud(val, NULL, NULL);

else

if(a->valeur>val)

a->filsG= ajoutArbreBRecherche(val,a->filsG);

else

a->filsD= ajoutArbreBRecherche(val,a->filsD);

return a;

}

 

//******ajout arbre b avl******

 

arbreB  ajoutArbreBRechercheAVL( element val, arbreB a)

{arbreB equilibre( arbreB a);

if(a==NULL)

a=creeNoeud(val, NULL, NULL);

else

if(a->valeur>val)

a->filsG= ajoutArbreBRechercheAVL(val,a->filsG);

else

a->filsD= ajoutArbreBRechercheAVL(val,a->filsD);

a=equilibre(a);

return a;

}

 

 

////==================>  creation d'un arbre binaire de recherche  (par utilisateur)

 

arbreB creationArbreBRech(int n)

{

arbreB a=NULL;

element val;

int i;

for(i=0; i<n;i++)

{ printf("entrer la valeur a ajouter ==>> ");

scanf("%d",&val);

a=ajoutArbreBRecherche(val,a);

}

return a;

}

 

arbreB creationArbreBRechAvl(int n)

{

 

arbreB a=NULL;

element val;

int i;

for(i=0; i<n;i++)

{ printf("entrer la valeur a ajouter ==>> ");

scanf("%d",&val);

a=ajoutArbreBRechercheAVL(val,a);

 

}

return a;

}

 

 

 

 

//**************************** Test Si Noeud Est Feuille ******************************

 

 

int noeudEstFeuille(arbreB a)

{

if(a==NULL)

return 0;

if(a->filsD==NULL && a->filsG==NULL)

return 1;

return 0;

}

 

//***************************** Test Si Noeud Est Interne ****************************

 

 

int noeudEstInterne(arbreB a)

{

return !noeudEstFeuille(a);

}

 

//*****************************Nbre De Noeud  dans un niveau*******************************************

 

int nbrNoeudNiveau(arbreB a, int n)

{

if(a==NULL)

return  0;

if(a!=NULL)

{

if(n==0)

return 1;

return nbrNoeudNiveau(a->filsG,n-1)+nbrNoeudNiveau(a->filsD,n-1);

}

 

}

 

 

int   nbrNo(arbreB a)

{

if(a==NULL)

return 0;

return 1+nbrNo(a->filsG)+nbrNo(a->filsD);

}

 

 

void parcourniveau(arbreB a,int n,int *cpt)//*cpt=0 ds le menu principale

{

if(a!=NULL)

{

if(n==0)

(*cpt)++;

parcourniveau(a->filsG,n-1,cpt);

parcourniveau(a->filsD,n-1,cpt);

}

}

 

 

int nbrNoeudAvanNiveau(arbreB a,int n)

{

if(a==NULL || n==0)

return 0;

return 1+nbrNoeudAvanNiveau(a->filsD,n-1)+nbrNoeudAvanNiveau(a->filsG,n-1);

}

 

 

 

int nbrNoeuApresNiveau(arbreB a,int n)

{

int i;

int s=0;

for(i=n;i<=hauteurArbre(a);i++)

s+=nbrNoeudNiveau(a,i);

return s;

 

}

 

 

int nbrNoeudInter(arbreB a)

{

if(a==NULL)

return 0;

if(noeudEstInterne(a)==0)

return 0;

return 1+nbrNoeudInter(a->filsD)+nbrNoeudInter(a->filsG);

}

 

//************************** Nbr De Feuille *********************************************

 

int nbrFeuille(arbreB a)

{

if(a==NULL)

return 0;

if(noeudEstFeuille(a)==1)

return 1+nbrFeuille(a->filsD)+nbrFeuille(a->filsG);

return nbrFeuille(a->filsD)+nbrFeuille(a->filsG);

}

 

 

int nbrFeuilleNiveau(arbreB a,int n)

{

if(a==NULL||n==0)

return 0;

if(noeudEstFeuille(a)==1)

return 1;

return nbrFeuilleNiveau(a->filsD,n-1)+nbrFeuilleNiveau(a->filsG,n-1);

}

 

//************************* Le Max De Deux Entier ****************************************

 

int max(int a,int b)

{

return (a>b)?a:b;

}

 

//************************** Hauteur *****************************************************

 

int hauteurArbre(arbreB a)

{

if(a==NULL)

return 0;

return 1+max(hauteurArbre(a->filsD),hauteurArbre(a->filsG));

}

 

//------------------------les defferent parcour ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

//************************* Parcour prefexe *************************************

 

void prcoursPrefixe(arbreB a)

{

if(a!=NULL)

{

printf("%d ",a->valeur);//<-- ici visitŽe (traitŽe)

prcoursPrefixe(a->filsG);

prcoursPrefixe(a->filsD);

}

}

 

//************************* Parcour infixe *************************************

 

void prcoursInfixe(arbreB a)

{

if(a!=NULL)

{

prcoursInfixe(a->filsG);

printf("%d ",a->valeur);//<-- ici visitŽe (traitŽe)

prcoursInfixe(a->filsD);

}

}

 

//************************* Parcour sufixe *************************************

 

void prcoursSuffixe(arbreB a)

{

if(a!=NULL)

{

prcoursSuffixe(a->filsG);

prcoursSuffixe(a->filsD);

printf("%d ",a->valeur);

}

}

 

//************************* Parcour Par Largeur ********************************

 

/*void parcoursLargeur(arbreB a)

{

file f=NULL;

arbreB atmp;

if(a!=NULL)

{

f=enfiler(a,f);

while( f!=NULL)

{

atmp=defiler(&f);

printf("%d ",atmp->valeur);

if(filsGauche(atmp)!=NULL)

f=enfiler(atmp->filsG,f);

if(filsDroit(atmp)!=NULL)

f=enfiler(atmp->filsD,f);

}

}

}

*/

//********************** Affichage d une arbreB ************************************

 

void affichenoeud(arbreB a)

{

if(a==NULL)

printf("[NULL,NULL,NULL]n");

else

if(a->filsG==NULL)

if(a->filsD==NULL)

printf("[%d,NULL,NULL]n",a->valeur);

else

printf("[%d,NULL,%d]n",a->valeur,a->filsD->valeur);

else

if(a->filsD==NULL)

printf("[%d,%d,NULL]n",a->valeur,a->filsG->valeur);

else

printf("[%d,%d,%d]n",a->valeur,a->filsG->valeur,a->filsD->valeur);

}

 

//============>

 

void affichearbreP(arbreB a)

{

if(a!=NULL)

{

affichenoeud(a);

affichearbreP(a->filsG);

affichearbreP(a->filsD);

}

}

 

 

 

//*****************affiche a largeur reccursive *******************

 

 

void parcourslongeurnv(arbreB a, int n)

{

if(a!=NULL)

{

if(n==0)

affichenoeud(a);

parcourslongeurnv(a->filsG,n-1);

parcourslongeurnv(a->filsD,n-1);

}

}

 

void parcourslargeur(arbreB a)

{

int i;

for(i=0;i<hauteurArbre(a);i++)

parcourslongeurnv(a,i);

}

 

//******************** Construction d une arbre B ********************

 

arbreB construirearbre(int n)

{

arbreB a=NULL;

int t,i;

srand(time(NULL));

for(i=0;i<n;i++)

{

t=rand()%2;

if(t==0)

a=ajouterGElementArbreB(a,rand()%50);

else

a=ajouterDElementArbreB(a,rand()%50);

}

return a;

}

/*

//************ Recherche element ***************************************

 

 

int rechercherEltArbre(arbreB a,element val)

{

if(a==NULL)

return 0;

if(a->valeur==val)

return 1;

return (rechercherEltArbre(filsGauche(a), val) || rechercherEltArbre(filsDroit(a), val) );

}

 

int rechercherEltArbreNIveau(arbreB a,element val,int n)

{

if(a==NULL)

return 0;

if(a->valeur==val && n==0)

return 1;

return (rechercherEltArbre(filsGauche(a), val,n-1) || rechercherEltArbre(filsDroit(a), val,n-1) );

}

 

 

int rechercherEltArbreRech(arbreB a,element val)

{

if(a==NULL)

return 0;

if(a->valeur==val)

return 1;

if(a->valeur>=val)

return rechercherEltArbreRech(a->filsG, val);

return rechercherEltArbreRech(a->flisD, val)

}*/

//********************** rechercher une valeur ds une arbre *******************************

 

int recherche(arbreB a, element val)

{

if(a!=NULL)

{

if(a->valeur==val)

return 1;

recherche(a->filsG,val);

recherche(a->filsD,val);

}

return 0;

}

 

//***************recherche u  element ds une arbreb***************

 

int recherchElmlt(arbreB a,element val)

{

if(a==NULL)

return 0;

if(a->valeur==val)

return 1;

return (recherchElmlt(a->filsG,val)||recherchElmlt(a->filsD,val));

}

 

 

//=============>  recherche dans un arbre apres un niveau

 

int recherchElmltNiveau(arbreB a,element val,int n)

{

if(a==NULL)

return 0;

if(a->valeur==val && n<=0)

return 1;

return (recherchElmltNiveau(a->filsG,val,n-1)||recherchElmltNiveau(a->filsD,val,n-1));

}

//********************Recherhce iterative ************************************************************************

 

 

int recherche_iter(arbreB a,int va)

{

while(a!=NULL)

{

if(a->valeur == va)

return 1;

if(a->valeur>va)

a=a->filsG;

else if(a->valeur<va)

a=a->filsD;

 

}

return 0;

}

//********************deux arbre sont egaux***************************************************

 

int teste_2_arbre_egaux(arbreB a,arbreB b)

{if (a!=NULL && b!=NULL)

{  if(a->valeur != b->valeur)

return 0;

return (teste_2_arbre_egaux(a->filsG,b->filsG) && teste_2_arbre_egaux(a->filsD,b->filsD));

 

}

return 1;

 

}

//*********************** Max d une arbre binaire de recherche  **************************************************

 

int  MaxArbreRech2(arbreB a)

{

if(a->filsD == NULL)

return a->valeur;

return MaxArbreRech2(a->filsD);

}

 

arbreB  MaxArbreRech(arbreB a)

{

if(a->filsD == NULL)

return a;

return MaxArbreRech(a->filsD);

}

/*

element maxnoeud(arbreB a)

{

if(a==NULL)

return 0;

if(a->filsG->valeur > a->valeur)

return a->filsG->valeur;

if(a->filsD->valeur > a->valeur)

return a->filsD->valeur;

}

 

void max1(arbreB a)

{

if(a!=NULL)

{

printf("%d n",maxnoeud(a));

max1(a->filsG);

max1(a->filsD);

}

}*/

 

//*******************suppression du racine *****************************

 

 

arbreB supprimerRacine(arbreB a)

{

arbreB tmp;

arbreB supprimerElt(int v, arbreB a);

if(a->filsG == NULL)

return a->filsD;

if(a->filsD == NULL)

return a->filsG;

tmp = MaxArbreRech(a->filsG);

a->valeur= tmp->valeur;

a->filsG = supprimerElt(tmp->valeur, a->filsG);

return a;

}

 

 

arbreB supprimerElt(int v, arbreB a)

{

if(a== NULL)

return a;

if(v == a->valeur)

return supprimerRacine(a);

if(v <= a->valeur)

a->filsG = supprimerElt(v, a->filsG);

else

a->filsD = supprimerElt(v, a->filsD);

return a;

}

 

 

//********************Vider un arbre ************************

 

 

arbreB viderArbreB(arbreB a)

{

arbreB aG;

arbreB aD;

if(a!= NULL)

{

aG = a->filsG;

aD = a->filsD;

a->filsG=viderArbreB(aG);

a->filsD=viderArbreB(aD);

free(a);

a=NULL;

return a;

}

return NULL;

}

 

//****************Supprimer un noeud *************************

 

/*

arbreB supprimerNoeudQcq(int v, arbreB a)

{

arbreB tmp;

if(a== NULL)

return a;

if(v == a->valeur)

{

tmp=a;

return viderArbreB(tmp);

}

if(rechercherArbre(a->filsG, v))

a->filsG = supprimerNoeudQcq(v, a->filsG);

else

a->filsD = supprimerNoeudQcq(v, a->filsD);

return a;

}

*/

 

//*********************** la difference **************************

 

 

int diffHauteur(arbreB a)

{

return (hauteurArbre(a->filsD)-hauteurArbre(a->filsG));

}

 

//***************** Rotation *******************************

 

//====================>  rotation a Guache

 

 

arbreB rotationG(arbreB A )

{

arbreB B;

B=A->filsD;

A->filsD=B->filsG;

B->filsG=A;

return B;

}

 

//====================>  rotation a Droit

 

arbreB rotationD(arbreB A)

{

arbreB B;

B=A->filsG;

A->filsG=B->filsD;

B->filsD=A;

return B;

}

 

//************************** equilibrer un arbre binaire de recherche *******

 

 

arbreB equilibre( arbreB a)

{

if(diffHauteur(a)>=2)

if(diffHauteur(a->filsD)>0)

a=rotationG(a);

else {

a->filsD=rotationD(a->filsD);

a=rotationG(a);

}

if(diffHauteur(a)<=-2)

if(diffHauteur(a->filsG)>=0)

{

a->filsG=rotationG(a->filsG);

a=rotationD(a);

}

else

a=rotationD(a);

return a;

}

 

arbreB equilibrefinal(arbreB a)

{

while(diffHauteur(a)>=2)

{

a=equilibre(a);

}

 

return a;

}

 

 

//*************** copier du tableu a une arbre *****

 

int *remplir(int n)

{

int *t,i;

srand(time(NULL));

t=malloc(n*sizeof(int));

for(i=0;i<n;i++)

t[i]=rand()%30;

return t;

}

 

void differentcopie(int p)

{arbreB a=NULL,b=NULL,c=NULL;

int i,n,*t;

n=pow(2,p)-1;

t=remplir(n);

for(i=0;i<n;i++)

{ printf("%d ",t[i]);

}

printf("n");

 

for(i=0;i<n;i++)

{

a=ajoutArbreBRechercheAVL(t[i],a);

b=ajoutArbreBRecherche(t[i],b);

c=ajouterGElementArbreB(c,t[i]);

}

 

printf(" l arbre B de rechercheAVL : n");

affichearbreP(a);

printf(" l arbre B de recherche : n");

affichearbreP(b);

printf(" l arbre B QlQ : n");

affichearbreP(c);

}

//***************construction

 

arbreB construir(int n)

{

arbreB a=NULL;

int i;

for(i=0;i<n;i++)

a=ajouterGElementArbreB(a,rand()%10);

return a;

}

 

 

 

 

////////////************************ EX 3 ********************

 

int maX_Iterative(arbreB a)

{ int max=0;

while(a)

{

max=a->valeur;

a=a->filsD;

}

return max;

}

 

int max_recursive(arbreB a)

{

 

if(a->filsD==NULL){

return a->valeur;

}

return max_recursive(a->filsD);

}

 

int min_Iterative(arbreB a)

{ int min=0;

while(a)

{

min=a->valeur;

a=a->filsG;

}

return min;

}

 

int min_recursive(arbreB a)//templ de complexite est log(n)

{

 

if(a->filsD==NULL)

return a->valeur;

return min_recursive(a->filsD);

}

////////////////////////////////////////////////////

//arbre.c

#include"arbre.h"

 

main()

{

arbreB a=NULL;

int choix,m,n,haut,p,val;

srand(time(NULL));

do{

printf("    -pour construir une arbre Binaire entre                 :  1n");

printf("    -pour afficher l arbre avec parcour prefixe etrer       :  2n");

printf("    -pour afficher l arbre avec parcour en  largeur etrer   :  3n");

printf("    -pour la hauteur de larbreB                             :  4n");

printf("    -pour savoir les nbare des racin avant un niveau        :  5n");

printf("    -pour le max de la arbre entrer                         :  6n");

printf("    -pour la defference d une arbre B                       :  7n");

printf("    -pour equilibre l arbre Binaire                         :  8n");

printf("    -pour tester que si larbre binaire de recherche         :  9n");

printf("    -pour suprimer une valeur de larbre                     :  10n");

printf("    -pour sortir du menu                                    :  0n");

printf("    -entrer vote choix                 :   ");

scanf("%d",&choix);

switch(choix)//equilibre( arbreB a)

{

case 1 :printf("entrer la taille de l arbre a saisi : ");

scanf("%d",&n);

a=creationArbreBRechAvl(n);

break;

case 2 :affichearbreP(a);

break;

/*

case 3 :parcourslargeur(a);

break;

case 4 :haut=hauteurArbre(a);

printf("nhauteur = %dn",haut);

break;

case 5 :printf("entrer le niveau avant le quele on calculer les racines  : ");

scanf("%d",&n);

 

printf("le nbre de racine est : %d n",m);

break;

case 6 :printf("le max de l arbre binaire est  : %d n ",MaxArbreRech2(a));

break;

case 7 :printf(" -la difference de l arbre est       :  %dnn",diffHauteur(a));

break;

case 8 :a=equilibrefinal(a);

break;

case 9 : if(testArbreRech(a)==1)

printf(" l arbre est une arbre binaire de recherhe n ");

if(testArbreRech(a)==0)

printf(" l arbre n'est pas  une arbre binaire de recherhe n ");

break;

case 10: printf("entrer la valeur a suprimer : ");

scanf("%d",&val);

a=supprimerElt(val,a);

break;

*/

default:printf(" le choix est invalide ");

 

}

}while(choix!=0);

 

printf("n tentrer la puissance  : ");

scanf("%d",&p);

differentcopie(p);

}