Algorithmique

1
Algorithmique

• Cours ENSG 2A, Septembre 2002
• Guillaume Caumon

http//www.ensg.inpl-nancy.fr/caumon/Teach
2
Introduction
Un cours dalgorithmique a Géol !???

• Algorithme suite dactions que devra effectuer
  un automate pour arriver à partir dun état
  initial, en un temps fini, à un résultat

3
Plan

• Mémoire, pointeurs (1h)
• Organisation dun programme (1h)
• Structures de données listes, arbres, tables...
  (8h)
• Algorithmique exemple des tris (2h)

4
Partie ILa mémoire
5
Les mémoires...

• RAM (Random Access Memory) 32 / 64 Mo
• Le disque dur quelques Go
• La mémoire virtuelle temps daccès 1000 fois
  plus long.

6
Mémoire et exécution
Code
Code objet du programme
Données statiques
Valeurs constantes
Pile
Piles dappels de fonctions
Tas
Allocation dynamique de mémoire
7
Intérêts des pointeurs
Gestion de lespace mémoire en cours dexécution
Modifications de variables passées en paramètres
de fonction
Représentation de tableaux accès direct et indexé
Références croisées
Fonctions virtuelles en programmation objet
8
Rappels sur les pointeurs
int a
a
Déclaration dun pointeur vers un entier
9
Rappels sur les pointeurs
int a
int a NULL
a
Déclaration dun pointeur vers un entier et
initialisation à NULL

10
Rappels sur les pointeurs
malloc(3sizeof(int))
Allocation dynamique de place mémoire (pour 3
entiers)
11
Rappels sur les pointeurs
int a malloc(3sizeof(int))
int a (int)malloc(3sizeof(int))
Allocation dynamique et assignement
12
Rappels sur les pointeurs
free(a)
a NULL
a
Désallocation dynamique
13
Rappels sur les pointeurs
int a (int)malloc(3sizeof(int))
int a (int)calloc(3, sizeof(int))
a (int)realloc(4sizeof(int))
14
Partie IISurvol darchitecture logicielle
15
Programme ??
lib
Librairies et fichiers objets
Programme
16
But du Jeu
17
Problèmes a résoudre
Complexité, Coût de maintenance
taille
temps
18
Organisation et réutilisation

• Organisation du code
• En fonctions, structures, etc.
• En fichiers

• Réutilisation
• Du code (fichiers source)
• Des fichiers binaires

• Réutilisation dun programme à lautre

19
Programmes et librairies
En C Exécutable ? main()
Pour la réutilisation, on utilise des
bibliothèques (ou librairies) de fonctions
dune description de chaque fonction (dans des
fichier .h den-tête, ou header), et du code
compilé correspondant (des .lib et .dll sous
PC, des .so et .a sous UNIX)
20
La Compilation Résumé
Fichiers den-tête C
Code source C
Préprocesseur
Code pré-processé
Librairies
Compilateur
Fichier(s) Objet
Editeur de liens
exécutable
a.out
.exe
21
Qualité dun programme
Architecture claire Réutilisabilité Structures
de données Algorithmes Documentation Tests
de robustesse
22
Partie III Introduction aux structures de données
23
Introduction
Problème métaphysique
24
Les tableaux
Accès indexé (de 0 à n-1 pour un tableau de n
éléments)
Stockage compact
Taille fixe, en général
Réajustement de taille coûteux en temps
Insertion délément onéreuse en temps.
25
Liste chaînée Spécifications
Créer une liste vide
Ajouter un élément (début / fin / milieu)
Retirer un élément (début / fin / milieu)
Détruire une liste
Trier les éléments dune liste
26
Liste chaînée Structures
Noeud








Tête
27
Liste chaînée Structures
Node_t
p_last
p_data
p_next




nb_elements
p_first
List_t
Data_t
28
Liste chaînée Header
typedef struct List_t struct Node_t
p_first_ struct Node_t p_last_ int
nb_elements_ List_t
typedef struct Node_t struct Data_t
p_data_ struct Node_t p_next_ Node_t
typedef struct Data_t ... Data_t
29
Liste chaînée Header
List_t list_create( void )
int list_insert_item( List_t list, Data_t
item ) int list_append_item( List_t list,
Data_t item ) int list_insert_item_before(
List_t list, Data_t to_insert, Data
list_item )
30
Liste chaînée Header
int list_destroy( List_t list )
int list_empty( List_t list )
Data_t list_remove_head( List_t list )
Data_t list_remove_tail( List_t list )
int list_remove_item( List_t list Data_t
item )
int list_sort( List_t list )
31
Liste chaînée Utilisation
Avant daller plus loin, vérifions si nos
spécifications sont suffisantes... Pour cela,
nous allons écrire un programme qui utilise les
fonctions du fichier list.h, sans nous préoccuper
de la façon dont elles sont implantées. But du
programme construire et trier une liste
dentiers par ordre croissant.
32
Liste chaînée Implantation

• Cf. code écrit au tableau
• pour résumer les principales règles à suivre
• Toujours tester la validité dun pointeur avant
  de lutiliser.
• Sassurer de ne jamais perdre ladresse dune
  zone allouée dynamiquement.
• Dans un programme, toute allocation par malloc
  ou calloc doit être suivie dune désallocation
  par free

33
Liste chaînée Spécialisations
Pile, ou Tas (Stack) structure LIFO
34
Liste chaînée Spécialisations
File, ou queue structure FIFO
void push(Data_t)
Data_t pop(void)
35
Introduction à la complexité
Annuaire avec noms et coordonnées
temps t
nombre dabonnés N
36
Sets ou Bags et tables
Stocker une seule fois le même élément dans le
conteneur.
Pas dordre
Accès rapide
Tables Associent une clé a un élément dans le
conteneur.
Besoin de fonctions de hachage
37
Structures de données linéaires
Taille fixe Accès direct
Tableaux
Taille variable Accès séquentiel
Listes chaînées
Unicité des éléments Accès rapide
Sets, Bags
Associe une clé unique et une valeur. Accès
rapide
Tables
38
Structures de données hiérarchiques les Arbres
Racine
39
Arbres Spécifications
Créer un arbre
Ajout / retrait dun noeud
Détruire un arbre
40
Arbres Structure de données
TreeNode_t
p_data
p_next
p_first_child
p_parent
Data_t
41
Tree.h
typedef struct TreeNode_t struct
TreeNode_t p_parent_ struct TreeNode_t
p_first_child_ Data_t p_data_ struct
TreeNode_t p_next_ TreeNode_t
TreeNode_t tree_add_node( TreeNode_t
p_parent, Data_t p_data )
42
Tree.h
TreeNode_t tree_find_root( TreeNode_t
p_parent, Data_t p_data )
void tree_preorder( TreeNode_t
p_root, void( do_it)( Data_t ) )
void tree_postorder( TreeNode_t
p_root, void( do_it)( Data_t ) )
43
Tree.h
void tree_inorder( TreeNode_t p_root, void(
do_it)( Data_t ) )
TreeNode_t tree_delete_branch( TreeNode_t
branch )
44
Arbres parcours pre-order
1
5
2
10
6
4
3
9
8
7
Pointeurs de fonctions...
45
Arbres parcours post-order
10
9
3
8
7
2
1
6
5
4
46
Arbres parcours in-order
4
9
2
10
6
3
1
8
7
5
47
Structures de données complexes Les Graphes
N1
N2
N3
N9
N7
N6
N5
N8
N4
N12
N10
N11
N14
N13
N16
N15
N18
N17
48
Partie IV Algorithmes et complexité exemple des
tris
49
Exemple Algorithmes de tri
Applications bases de données géométrie
algorithmique ....
Tri dun tableau de taille n n! possibilités
Fonctions de comparaison lt dechange
50
Tri par remplacement

• Complexité en temps o(n(n-1)) o(n2)
• Mémoire duplication du tableau.

51
Tri par permutation

• Complexité en temps o(n(n-1)/2) o(n2)
• Mémoire tableau non dupliqué

52
Tri à bulles Principe
Echange de deux éléments adjacents du tableau.
53
Tri à bulles Algo
Tableau tab Booleen permute lt- vrai int i lt-
0 Tant que permute Faire permute faux Pour
j de n-1 à i 1 Faire Si tabj-1 gt tabj
Faire swap( tabj-1, tabj )
permute vrai FinSi FinPour i Finttque
54
Tri à bulles Commentaires

• Complexité en temps o(n(n-1)/2) o(n2)
• Mémoire tableau non dupliqué

55
Tri par sélection 4que
On sépare le tableau en p ensembles. On cherche
un minimum pour chaque sous-ensemble On prend le
minimum de ces minima. On échange cet élément
avec le premier élément etc.

• n ( p n/p ) tests
• o( n ?n ) pour p ?n

56
Tri par segmentation (quicksort)
Méthode diviser pour régner

• On recherche une valeur pivot Tj.
• On échange les valeurs de sorte que
• tout élément de T0,Tj-1 soit inférieur a Tj,
• tout élément de Tj1, Tn soit supérieur a Tj

On pivote récursivement sur T0,Tj-1 et Tj1,
Tn.
57
Tri par segmentation (quicksort)
3 1 4 6 3 2 9 5 7 1 8 2
seg (0,11)
3 1 2 6 3 2 9 5 7 1 8 4
3 1 2 1 3 2 9 5 7 6 8 4
2 1 2 1 3 3 9 5 7 6 8 4
58
Tri par segmentation (quicksort)

• Complexité dans le cas favorable
• log2(n) nombre de segmentations
• 0 permutations
• o(n log2 n) comparaisons
• Complexité dans le cas défavorable
• n nombre de segmentations
• o(n2) permutations
• o(n2) comparaisons

59
Conclusion
Fonctionnement dun programme et dun ordinateur
Programmation en C
Algorithmique et structures de données sont liées.
Les exemples étudiés ont été implantés en C, mais
le langage est plus un outil quune fin en soi.
Bon courage pour vos projets !
60
References

• Web
• Aho et al. Structures de donnees et algorithmes,
  Addisson-Wesley / InterEditions. 1989.
• Aho et Ullman. Concepts fondamentaux de
  linformatique, Dunod. 1993.
• Sedgewick. Algorithmes en C. Addisson-Wesley /
  InterEditions. 1991.

61
Annexe Pointeurs de fonction
But paramétrer des fonctions par dautres
fonctions pour modifier leur actions.
Déclaration type ( nom_de_fonction)
(arguments) Utilisation (
nom_de_fonction) (arg1, arg2, arg3,...)
62
Annexe Pointeurs de fonction
short tab10 short carre( short v ) return a
a void imprimer( int nb_elems, short (
function )( short ) ) for( i 0 i lt
nb_elems i ) printf( d , ( function) (
tabi ) ) int main() for( i 0 i lt
10 i ) tabi n imprimer( 10, carre
)
Retour aux arbres