Jean-Lou Desbarbieux et St´ephane Doncieux UMPC 2012/2013
Quizz pointeurs
Que font les instructions suivantes : i n t n =42;
i n t ∗m=n ;
∗m = 2 4 ;
Quizz pointeurs
Que font les instructions suivantes : i n t n =42;
i n t ∗m=n ;
∗m = 2 4 ;
→ erreur de segmentation ! ! Il manque un ’&’ `a la 2eme ligne :
i n t n =42;
i n t ∗m=&n ; // & a a j o u t e r
∗m = 2 4 ; R´esultat ?
Quizz pointeurs
Que font les instructions suivantes : i n t t [ 4 ] ={0 , 1 , 2 , 3};
i n t ∗m=t ;
∗(m++) += 3 ;
∗(++m) += 4 ; (∗m)++;
Que fait la fonction ? Comment y fait-on appel ?
v o i d m y s t e r e (i n t ∗n , i n t m) { i f( (m= = 0 )||(m==1)) {
∗n =1;
} e l s e {
m y s t e r e ( n ,m−1);
∗n ∗= m;
} }
Initialiser le contenu d’un tableau dans une fonction
I Possible ?
I Si oui :
I quel prototype ?
I quelle fonction ?
I comment utiliser la fonction ?
Initialiser le contenu d’un tableau dans une fonction
v o i d i n i t i a l i s e r (i n t ∗tab , i n t n , i n t v a l =0) { unsigned i n t i ;
f o r ( i =0; i<n ; i ++) { t a b [ i ]= v a l ; }
}
Allouer un tableau dans une fonction
I Possible ?
I Si oui :
I quel prototype ?
I quelle fonction ?
Allouer un tableau dans une fonction
i n t ∗a l l o u e r T a b l e a u (i n t n ) {
i n t ∗t a b =(i n t ∗) m a l l o c ( n∗s i z e o f(i n t ) ) ; i f ( t a b == NULL) {
p r i n t f ( ” Probleme p e n d a n t l ’ a l l o c a t i o n\n” ) ; }
r e t u r n t a b ; }
Changer la taille d’un tableau dans une fonction
I Possible ?
I Si oui :
I quel prototype ?
I quelle fonction ?
Changer la taille d’un tableau dans une fonction
i n t ∗c h a n g e r T a i l l e T a b l e a u (i n t ∗tab , i n t n ) { i n t ∗t a b 2 =(i n t ∗) r e a l l o c ( tab , n∗s i z e o f(i n t ) ) ; i f ( t a b 2 == NULL) {
p r i n t f ( ” Probleme p e n d a n t l ’ a l l o c a t i o n\n” ) ; r e t u r n t a b ;
}
r e t u r n t a b 2 ; }
Changer la taille d’un tableau dans une fonction (bis)
Autre ´ecriture : renvoievoid et modifie le param`etre transmettant le tableau.
v o i d c h a n g e r T a i l l e T a b l e a u 2 (i n t ∗∗tab , i n t n ) { // a t t e n t i o n , t a b e s t un ’ i n t ∗∗’
i n t ∗t a b 2 =(i n t ∗) r e a l l o c (∗tab , n∗s i z e o f(i n t ) ) ; i f ( t a b 2 == NULL) {
p r i n t f ( ” Probleme p e n d a n t l ’ a l l o c a t i o n\n” ) ; r e t u r n;
}
∗t a b=t a b 2 ; }
Structure
s t r u c t p o i n t { f l o a t x ; f l o a t y ; f l o a t z ; };
i n t main ( ) {
p r i n t f ( ” s i z e o f ( p o i n t)=%d\n” , s i z e o f(s t r u c t p o i n t ) ) ; }
Qu’est-ce qui est affich´e `a l’´ecran ?
Structure
s t r u c t p o i n t { f l o a t x ; f l o a t y ; f l o a t z ; };
i n t main ( ) {
p r i n t f ( ” s i z e o f ( p o i n t)=%d\n” , s i z e o f(s t r u c t p o i n t ) ) ; r e t u r n 0 ;
}
Qu’est-ce qui est affich´e `a l’´ecran ? sizeof(struct point)=12
Structure et passage de param`etres
v o i d f (s t r u c t p o i n t p ) { p . x =42;
p . y =24;
p . z =12;
}
i n t main ( ) {
s t r u c t p o i n t p ={1 , 2 , 3}; f ( p ) ;
p r i n t f ( ”p . x=%f p . y=%f p . z=%f\n” , p . x , p . y , p . z ) ; r e t u r n 0 ;
}
Qu’est-ce qui est affich´e `a l’´ecran ?
Structure et passage de param`etres
v o i d f (s t r u c t p o i n t p ) { p . x =42;
p . y =24;
p . z =12;
}
i n t main ( ) {
s t r u c t p o i n t p ={1 , 2 , 3}; f ( p ) ;
p r i n t f ( ”p . x=%f p . y=%f p . z=%f\n” , p . x , p . y , p . z ) ; r e t u r n 0 ;
}
Qu’est-ce qui est affich´e `a l’´ecran ?
p.x=1.000000 p.y=2.000000 p.z=3.000000
Comment faire pour que les modifications du param`etre pne soient pas perdues `a la fin de la fonction f?
Structure et passage de param`etres
v o i d f (s t r u c t p o i n t ∗p ) {
p−>x =42;
p−>y =24;
p−>z =12;
}
i n t main ( ) {
s t r u c t p o i n t p ={1 , 2 , 3}; f (&p ) ;
p r i n t f ( ”p . x=%f p . y=%f p . z=%f\n” , p . x , p . y , p . z ) ; r e t u r n 0 ;
}
Qu’est-ce qui est affich´e `a l’´ecran ?
p.x=42.000000 p.y=24.000000 p.z=12.000000
Structure, tableaux et passage de param`etres
v o i d f (i n t s [ 3 ] ) { s [ 0 ] = 4 2 ;
p r i n t f ( ” s i z e o f ( s)=%d\n” ,s i z e o f( s s ) ) ; }
i n t main (v o i d) { i n t s ;
s [ 0 ] = 2 4 ; f ( s ) ;
p r i n t f ( ” s [0]=%d\n” , s [ 0 ] ) ; }
Qu’est-ce qui est affich´e `a l’´ecran ?
Structure, tableaux et passage de param`etres
v o i d f (i n t s [ 3 ] ) { s [ 0 ] = 4 2 ;
p r i n t f ( ” s i z e o f ( s)=%d\n” ,s i z e o f( s s ) ) ; }
i n t main (v o i d) { i n t s ;
s [ 0 ] = 2 4 ; f ( s ) ;
p r i n t f ( ” s [0]=%d\n” , s [ 0 ] ) ; }
Qu’est-ce qui est affich´e `a l’´ecran ? sizeof(s)=4
s[0]=42
Structure, tableaux et passage de param`etres
s t r u c t s{ i n t t [ 3 ] ; };
v o i d f (s t r u c t s s t ) { s t . t [ 0 ] = 4 2 ;
p r i n t f ( ” s i z e o f s t=%d\n” ,s i z e o f( s t ) ) ; }
i n t main (v o i d) { s t r u c t s s t ; s t . t [ 0 ] = 2 4 ; f f ( s t ) ;
p r i n t f ( ” s t . t [0]=%d\n” , s t . t [ 0 ] ) ; }
Qu’est-ce qui est affich´e `a l’´ecran ?
Structure, tableaux et passage de param`etres
s t r u c t s{ i n t t [ 3 ] ; };
v o i d f (s t r u c t s s t ) { s t . t [ 0 ] = 4 2 ;
p r i n t f ( ” s i z e o f ( s t )=%d\n” ,s i z e o f( s t ) ) ; }
i n t main (v o i d) { s t r u c t s s t ; s t . t [ 0 ] = 2 4 ; f f ( s t ) ;
p r i n t f ( ” s t . t [0]=%d\n” , s t . t [ 0 ] ) ; }
Qu’est-ce qui est affich´e `a l’´ecran ? sizeof(st)=12
st.t[0]=24
UE C avanc´e cours 7: Listes Chaˆın´ees
Jean-Lou Desbarbieux et St´ephane Doncieux UMPC 2012/2013
Sommaire
Introduction
Listes chaˆın´ees
Limitations des tableaux
Une solution intuitive : l’autor´ef´erencement Les listes
Piles
Listes chaˆın´ees
Mieux que les tableaux ?
De mˆeme que les tableaux les listes chaˆın´ees servent `a stocker un ensemble d’´el´ements de mˆeme type.
Sans les limitations des tableaux :
I inserer un ´el´ement sans avoir avoir `a recopier la suite du tableau,
I retirer un ´el´ement sans avoir avoir `a recopier la suite du tableau,
I ne pas n´ecessiter l’utilisation de m´emoire contigu¨e,
I permet de faire varier dynamiquement la taille,
I ...
Insertion d’un ´el´ement dans un tableau
En supposant que le tableau ait ´et´e allou´e dynamiquement, il faut :
I faire appel `a realloc pour taille + 1,
I d´eterminer l’emplacement de l’´el´ement `a ins´erer,
I d´ecaler d’une position tous les ´el´ements situ´es apr`es l’insertion.
I ins´erer le nouvel ´el´ement.
La ou les copies de portions du tableau est/sont coˆuteuses.
Efficacit´e et contraintes des tableaux
Un tableau correspond `a une zone contigu¨e de la m´emoire, pour acc´eder au i`eme ´el´ement il suffit de connaˆıtre l’adresse du premier :
#d e f i n e t a i l l e i n t e r 10 . . .
i n t d e j a t i r e [ t a i l l e i n t e r ] ; i n t v a l ;
. . . do {
v a l=r a n d ()% t a i l l e i n t e r ; }
w h i l e( ∗( d e j a t i r e + v a l ) ) ;
Ce `a quoi nous sommes prˆets `a renoncer
On est prˆets `a renoncer `a l’acc`es index´e pour gagner en flexibilit´e.
Id´ee
On conserve l’organisation en tableau mais on accroche `a chaque
´el´ement, l’indice du suivant :
typedef s t r u c t u n e l e m e n t {
i n t d a t a ;
unsigned i n t i n d i c e s u i v a n t ; } U n e l e m e n t ;
La fonction ins´erer
pour ins´erer un ´el´ement, il suffit de :
I faire appel `a realloc pour taille + 1,
I ajouter l’´el´ement en fin de tableau,
I d´eterminer l’emplacement de l’´el´ement `a ins´erer,
I modifier le champ ”indice suivant” de l’´el´ement pr´ec´edent l’´el´ement `a ins´erer,
I modifier le champ ”indice suivant” de l’´el´ement ins´er´e en lui attribuant l’indice de l’´el´ement suivant celui ins´er´e.
L’appel `a realloc peut provoquer une recopie du tableau.
structure de liste
On g´en´eralise l’id´ee intuitive `a autre chose qu’un tableau. On doit donc se passer d’indice !
typedef s t r u c t u n e l e m e n t {
char mot [ 3 0 ] ;
s t r u c t u n e l e m e n t ∗s u i v a n t ; } U n e l e m e n t ;
structure de liste
ou bien :
typedef s t r u c t u n e l e m e n t ∗P u n e l e m e n t ; typedef s t r u c t u n e l e m e n t
{
char mot [ 3 0 ] ;
P u n e l e m e n t s u i v a n t ; } U n e l e m e n t ;
Cr´eation d’un ´el´ement
P u n e l e m e n t c r e e r e l e m e n t (c h a r ∗mot ) {
P u n e l e m e n t e l ;
e l = ( P u n e l e m e n t ) m a l l o c (s i z e o f( U n e l e m e n t ) ) ; i f ( e l == NULL) r e t u r n NULL ;
s t r c p y ( e l−>mot , mot ) ;
e l−>s u i v a n t = NULL ;
r e t u r n e l ; }
D´eclaration d’une liste
P u n e l e m e n t m a l i s t e = NULL ;
Insertion en d´ebut de liste
P u n e l e m e n t i n s e r e r e l e m e n t d e b u t ( P u n e l e m e n t p l i s t e , P u n e l e m e n t e l )
{
e l−>s u i v a n t = p l i s t e ;
r e t u r n e l ; }
Insertion en fin de liste
P u n e l e m e n t i n s e r e r e l e m e n t f i n ( P u n e l e m e n t p l i s t e , P u n e l e m e n t e l )
{
P u n e l e m e n t p l = p l i s t e ; i f ( p l i s t e == NULL) r e t u r n e l ;
w h i l e ( p l−>s u i v a n t ) {
p l = p l−>s u i v a n t ; }
p l−>s u i v a n t = e l ;
r e t u r n p l i s t e ; }
Insertion en place dans une liste tri´ee
P u n e l e m e n t i n s e r e r e n p l a c e ( P u n e l e m e n t p l i s t e , P u n e l e m e n t e l )
{
P u n e l e m e n t p l = p l i s t e ; i f ( p l i s t e == NULL)
r e t u r n e l ;
i f ( s t r c m p ( p l−>mot , e l−>mot ) >0) {
e l−>s u i v a n t=p l ; r e t u r n e l ; }
w h i l e ( p l−>s u i v a n t ) {
i f ( s t r c m p ( p l−>s u i v a n t−>mot , e l−>mot ) > 0 ) b r e a k;
p l = p l−>s u i v a n t ; }
e l−>s u i v a n t = p l−>s u i v a n t ;
p l−>s u i v a n t = e l ;
r e t u r n p l i s t e ;}
Recherche d’un ´el´ement dans une liste
P u n e l e m e n t r e c h e r c h e r e l e m e n t ( P u n e l e m e n t p l i s t e , c h a r ∗mot )
{
w h i l e( p l i s t e ) {
i f ( s t r c m p ( p l i s t e−>mot , mot ) == 0 ) r e t u r n p l i s t e ;
p l i s t e = p l i s t e−>s u i v a n t ; }
r e t u r n NULL ; }
Suppression d’un ´el´ement dans une liste
P u n e l e m e n t e x t r a i r e e l e m e n t ( P u n e l e m e n t p l i s t e , P u n e l e m e n t p e l )
{
P u n e l e m e n t p l = p l i s t e ; i f( p l == p e l )
r e t u r n p l i s t e−>s u i v a n t ; w h i l e ( p l−>s u i v a n t ) {
i f ( p l−>s u i v a n t == p e l ) {
p l−>s u i v a n t = p e l−>s u i v a n t ; b r e a k;
}
p l = p l−>s u i v a n t ; }
r e t u r n p l i s t e ; }
D´esallocation d’une liste compl`ete
P u n e l e m e n t d e t r u i r e l i s t e ( P u n e l e m e n t p l i s t e ) {
P u n e l e m e n t p l = p l i s t e , p e l ; w h i l e( p l )
{
p e l = p l ;
p l = p l−>s u i v a n t ; d e t r u i r e e l e m e n t ( p e l ) ; }
r e t u r n NULL ; }
Listes doublement chaˆın´ees
typedef s t r u c t u n e l e m e n t ∗P u n e l e m e n t ; typedef s t r u c t u n e l e m e n t
{
char mot [ 3 0 ] ;
P u n e l e m e n t p r e c e d e n t ; P u n e l e m e n t s u i v a n t ; } U n e l e m e n t ;
Listes versus tableaux
Les listes :
I flexibilit´e (insertion extraction).
I acc`es s´equentiel.
les tableaux :
I rapidit´e,
I compacit´ee,
I acc`es al´eatoire.
Piles
Il est possible d’impl´ementer des piles `a l’aide de listes chaˆın´ees.
Les piles offrent deux primitives d’acc`es :
PUSH : permet d’empiler un ´el´ement ; void push(T pile pile, Telem d) ;
POP : permet de d´epiler un ´el´ement. void pop(T pile pile, Telem *d) ;
Piles LIFO ou FILO
Si on consid`ere que le sommet de la pile est en tˆete de liste alors : PUSH est synonyme de inserer en tete et POP est synonyme de extraire en tete.
Files FIFO ou LILO
Si on consid`ere que le sommet de la pile est en tˆete de liste alors : PUSH est synonyme de inserer en tete et POP est synonyme de extraire en queue.
liste chaˆın´ee circulaire
Permet de parcourir un ensemble d’´el´ements suivant une s´equence donn´ee, sans avoir `a se soucier d’avoir atteint la fin de la liste.
C’est tout pour aujourd’hui !
UE C avanc´e cours 8: Arbres
Jean-Lou Desbarbieux et St´ephane Doncieux UMPC 2012/2013
Sommaire
Introduction et d´efinitions
Arbres binaires
Arbres binaire de recherches Arbres de d´ecision binaire (BDD)
Parcours
D´efinition d’un arbre
L’arbre est une structure autor´ef´erentielle, c’est une g´en´eralisation de la liste : alors qu’un ´el´ement de liste a un seul successeur (l’´el´ement suivant) dans un arbre il peut y avoir plusieurs sucesseurs.
Notion de noeud
L’´el´ement de base d’un arbre s’appelle le noeud. C’est une structure compos´ee de :
I un champ de donn´ee ;
I plusieurs pointeurs vers des noeuds.
Terminologie
On utilise classiquement la terminologie suivante pour d´ecrire les arbres :
P`ere Le p`ere A d’un noeud B est l’unique noeud tel que :
I un des sous-arbres contient B ;
I hauteur(A) - hauteur(B) = 1.
fils Les fils d’un noeud A sont les noeuds qui ont A pour p`ere.
fr`eres Les fr`eres d’un noeud A sont les noeuds qui poss`edent le mˆeme p`ere que A.
Sous-arbre Un sous-arbre d’un noeud A est un arbre dont la racine est un fils de A.
Terminologie suite
Racine La racine de l’arbre est l’unique noeud qui n’a pas de p`ere.
Feuille Une feuille est un noeud qui n’a pas de fils.
Branche Une Branche est un arc qui relie deux noeuds.
Hauteur Nombre maximum de branches entre la racine et une feuille.
Arbres n-aires
Un arbre dont les noeuds ont au plus n fils est un arbre n-aire.
Lorsque n vaut 2, l’arbre est dit binaire. Dans le cas particulier de l’arbre binaire on utilise les termes de fils gauche et fils droit d’un noeud, ainsi que les notions de sous-arbre gauche et de sous-arbre droit.
D´eclaration du noeud
typedef s t r u c t u n n o e u d ∗P u n n o e u d ; typedef s t r u c t u n n o e u d
{
i n t d a t a ;
P u n n o e u d f i l s g a u c h e ; P u n n o e u d f i l s d r o i t ; /∗o p t i o n n e l l e m e n t∗/ P u n n o e u d p e r e ; } Un noeud ; P u n n o e u d m o n a r b r e ;
Arbres binaires de recherche (ABR)
5
8
7 3
1 4
Tous les noeuds du sous-arbre de gauche ont une valeur inf´erieure.
Tous les noeuds du sous-arbre de droite ont une valeur sup´erieure ou ´egale.
Arbres de d´ecision binaire (BDD)
1 1 0
0 1 0
1 1 0
A?
C?
B?
0
Parcours en profondeur
Le parcours dit en profondeur d’abord consiste `a explorer un arbre de haut en bas puis de gauche `a droite.
On distingue trois types de parcours en profondeurs :
I le parcours pr´efixe traite le noeud courant puis le sous-arbre gauche puis le sous-arbre droit.
I le parcours infixe traite le sous-arbre gauche puis le noeud courant puis le sous-arbre droit.
I le parcours postfixe traite le sous-arbre gauche puis le sous-arbre droit puis le noeud courant.
Parcours en profondeur recursif prefixe
Affichage du contenu d’un arbre binaire de recherche.
v o i d d i s p ( P u n n o e u d a r b r e ) {
i f ( a r b r e ) {
p r i n t f ( ”%d ” , a r b r e−>d a t a ) ; d i s p ( a r b r e−>f i l s g a u c h e ) ; d i s p ( a r b r e−>f i l s d r o i t ) ; }
}
Parcours en profondeur recursif infixe
v o i d d i s p ( P u n n o e u d a r b r e ) {
i f ( a r b r e ) {
d i s p ( a r b r e−>f i l s g a u c h e ) ; p r i n t f ( ”%d ” , a r b r e−>d a t a ) ; d i s p ( a r b r e−>f i l s d r o i t ) ; }
}
Parcours en profondeur recursif postfixe
v o i d d i s p ( P u n n o e u d a r b r e ) {
i f ( a r b r e ) {
d i s p ( a r b r e−>f i l s g a u c h e ) ; d i s p ( a r b r e−>f i l s d r o i t ) ; p r i n t f ( ”%d ” , a r b r e−>d a t a ) ; }
}
Parcours en profondeur it´eratif prefixe
v o i d d i s p ( P u n n o e u d a r b r e ) {
P u n n o e u d p n o e u d = a r b r e ; T p i l e p i l e = NULL ;
i f ( p n o e u d ) {
push ( p i l e , p n o e u d ) ; do
{
pop ( p i l e , &p n o e u d ) ;
p r i n t f ( ”%d ” , p noeud−>d a t a ) ;
i f( p noeud−>d r o i t ) push ( p i l e , p noeud−>d r o i t ) ; i f( p noeud−>g a u c h e ) push ( p i l e , p noeud−>g a u c h e ) ; }
w h i l e( p i l e ) ; }
}
Parcours en largeur
v o i d d i s p ( P u n n o e u d a r b r e ) {
P u n n o e u d p n o e u d = a r b r e ; T f i f o f i f o = NULL ;
i f ( p n o e u d ) {
push ( f i f o , p n o e u d ) ; do
{
pop ( f i f o , &p n o e u d ) ;
p r i n t f ( ”%d ” , p noeud−>d a t a ) ;
i f( p noeud−>g a u c h e ) push ( p i l e , p noeud−>g a u c h e ) ; i f( p noeud−>d r o i t ) push ( p i l e , p noeud−>d r o i t ) ; }
w h i l e( f i f o ) ; }
}