algorithmique l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Algorithmique PowerPoint Presentation
Download Presentation
Algorithmique

Loading in 2 Seconds...

play fullscreen
1 / 62

Algorithmique - PowerPoint PPT Presentation


  • 438 Views
  • Uploaded on

Algorithmique. Cours ENSG 2A, Septembre 2002 Guillaume Caumon. http://www.ensg.inpl-nancy.fr/~caumon/Teach. Introduction. Un cours d’algorithmique a Géol… !???.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Algorithmique' - Audrey


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
algorithmique

Algorithmique

Cours ENSG 2A, Septembre 2002

Guillaume Caumon

http://www.ensg.inpl-nancy.fr/~caumon/Teach

introduction
Introduction

Un cours d’algorithmique a Géol… !???

Algorithme = suite d’actions que devra effectuer un automate pour arriver à partir d’un état initial, en un temps fini, à un résultat

slide3
Plan
  • Mémoire, pointeurs (1h)
  • Organisation d’un programme (1h)
  • Structures de données: listes, arbres, tables... (8h)
  • Algorithmique: exemple des tris (2h)
les m moires
Les mémoires...
  • RAM (Random Access Memory): 32 / 64 Mo
  • Le disque dur: quelques Go
  • La mémoire virtuelle: temps d’accès 1000 fois plus long.
m moire et ex cution
Mémoire et exécution

Code

Code objet du programme

Données statiques

Valeurs constantes

Pile

Piles d’appels de fonctions

Tas

Allocation dynamique de

mémoire

int r ts des pointeurs
Intérêts des pointeurs

Gestion de l’espace mémoire en cours d’exé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

rappels sur les pointeurs
Rappels sur les pointeurs

int* a;

a

Déclaration d’un pointeur vers un entier

rappels sur les pointeurs9
Rappels sur les pointeurs

int* a;

int* a = NULL;

a

Déclaration d’un pointeur vers un entier

et initialisationà “NULL”

rappels sur les pointeurs10
Rappels sur les pointeurs

malloc(3*sizeof(int));

Allocation dynamique de place mémoire

(pour 3 entiers)

rappels sur les pointeurs11

a

*a

Rappels sur les pointeurs

int* a = malloc(3*sizeof(int));

int* a = (int*)malloc(3*sizeof(int));

Allocation dynamique et assignement

rappels sur les pointeurs12

*a

Rappels sur les pointeurs

free(a);

a = NULL;

a

Désallocation dynamique

rappels sur les pointeurs13
Rappels sur les pointeurs

int* a = (int*)malloc(3*sizeof(int));

int* a = (int*)calloc(3, sizeof(int));

a = (int*)realloc(4*sizeof(int));

programme

bin

Fichiers de description (header)

.dll

.so

.h

.c

.lib

.o

Fichiers d’implantation (source code)

include

a.out

.exe

Exécutable(s)

src

Programme ??

lib

Librairies et fichiers objets

Programme

but du jeu

Fichiers source = Instructions dans un langage de programmation

Application, qui parle directement a l’ordinateur

But du Jeu
probl mes a r soudre
Problèmes a résoudre

Complexité,

Coût de maintenance

taille

temps

organisation et r utilisation
Organisation et réutilisation…
  • Organisation du code :
    • En fonctions, structures, etc.
    • En fichiers
  • Réutilisation :
    • Du code (fichiers source)
    • Des fichiers binaires
  • Réutilisation d’un programme à l’autre
programmes et librairies
Programmes et librairies

En C :

Exécutable ↔ main()

Pour la réutilisation, on utilise des bibliothèques (ou librairies) de fonctions : d’une description de chaque fonction (dans des fichier “.h” d’en-tête, ou header), et du code compilé correspondant (des “.lib” et “.dll” sous PC, des “.so” et “.a” sous UNIX)

la compilation r sum

.lib

.c

.h

.so

.o

La Compilation : Résumé

Fichiers d’en-tête C

Code source C

Préprocesseur

Code pré-processé

Librairies

Compilateur

Fichier(s) Objet

Editeur de liens

exécutable

a.out

.exe

qualit d un programme
Qualité d’un programme

Architecture claire

Réutilisabilité

Structures de données +

Algorithmes +

Documentation +

Tests de robustesse +

slide22

Partie III

Introduction aux structures de données

introduction23

“Comment Organiser au Mieux l’Information

dans un Programme ?”

Structures

Tableaux

Structures de données

struct Data_t {

int index_;

char* value_;

} Data_t;

int tab[10];

Introduction

Problème métaphysique:

les tableaux
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.

liste cha n e sp cifications
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 d’une liste

liste cha n e structures27
Liste chaînée : Structures

Node_t

p_last

p_data

p_next

nb_elements

p_first

List_t

Data_t

liste cha n e header
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;

liste cha n e header29
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

);

liste cha n e header30
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 );

liste cha n e utilisation
Liste chaînée : Utilisation

Avant d’aller 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 d’entiers par ordre croissant.

liste cha n e implantation
Liste chaînée : Implantation
  • Cf. code écrit au tableau;
  • pour résumer les principales règles à suivre:
    • Toujours tester la validité d’un pointeur avant de l’utiliser.
    • S’assurer de ne jamais perdre l’adresse d’une zone allouée dynamiquement.
    • Dans un programme, toute allocation parmallocoucalloc doit être suivie d’une désallocation parfree
liste cha n e sp cialisations

void push(Data_t*)

Data_t* pop(void)

Liste chaînée : Spécialisations

Pile, ou Tas (Stack): structure LIFO

liste cha n e sp cialisations34
Liste chaînée : Spécialisations

File, ou queue : structure FIFO

void push(Data_t*)

Data_t* pop(void)

introduction la complexit

t = a · N2

t = a · 2N

t = a · N

t = a · logN

Introduction à la complexité

Annuaire avec noms et coordonnées

temps t

nombre d’abonnés N

sets ou bags et tables
Sets ou Bags et tables

Stocker une seule fois le même élément

dans le conteneur.

Pas d’ordre

Accès rapide

Tables : Associent une clé a un élément

dans le conteneur.

Besoin de fonctions de hachage

structures de donn es lin aires
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

structures de donn es hi rarchiques les arbres

B1

B2

B3

F1

B4

B5

B6

F2

B7

B8

B9

B10

F3

F4

F5

F6

F7

F8

F9

F10

Structures de données hiérarchiques: les Arbres

Racine

arbres sp cifications

Parcours pre-order

Parcours post-order

Parcours in-order

Arbres: Spécifications

Créer un arbre

Ajout / retrait d’un noeud

Détruire un arbre

arbres structure de donn es
Arbres: Structure de données

TreeNode_t

p_parent

p_first_child

p_data

p_next

Data_t

tree h
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

);

tree h42
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* )

);

tree h43
Tree.h

void tree_inorder(

TreeNode_t* p_root,

void(* do_it)( Data_t* )

);

TreeNode_t* tree_delete_branch(

TreeNode_t* branch

);

arbres parcours pre order
Arbres: parcours pre-order

1

2

5

3

4

6

10

7

8

9

Pointeurs de fonctions...

structures de donn es complexes les graphes
Structures de données complexes: Les Graphes

N1

N2

N3

N4

N5

N6

N7

N8

N9

N12

N10

N11

N13

N14

N15

N16

N17

N18

slide48

Partie IV

Algorithmes et complexité :

exemple des tris

exemple algorithmes de tri
Exemple : Algorithmes de tri

Applications:

bases de données

géométrie algorithmique

....

Tri d’un tableau de taille n :

n! possibilités

Fonctions:

de comparaison “<“

d’echange

tri par remplacement

Besoins

min_index, max_value, comp

  • Algo

tableaux entree, sortie

int max = max_value(entree)

Pouri de 1 à n Faire:

int j <- min_index(entree)

sortie[i] <- entree[j]

entree[j] <- max

FinPour

Tri par remplacement
  • Complexité en temps : o(n(n-1)) ~ o(n2)
  • Mémoire: duplication du tableau.
tri par permutation

Besoins

min_index, swap, comp

  • Algo

Tableau entrée

Pour i de 1 à n Faire:

int j <- min_index(entree,i)

Si j ≠ i Faire

swap(entree[i],entree[j])

FinSi

FinPour

Tri par permutation
  • Complexité en temps : o(n(n-1)/2) ~ o(n2)
  • Mémoire: tableau non dupliqué
tri bulles principe

Besoins

swap, comp

Tri à bulles: Principe

Echange de deux éléments adjacents du tableau.

tri bulles algo
Tri à bulles: Algo

Tableau tab

Booleen permute <- vrai

int i <- 0

Tant que permute Faire

permute = faux

Pour j de n-1 à i + 1 Faire

Si tab[j-1] > tab[j] Faire

swap( tab[j-1], tab[j] )

permute = vrai

FinSi

FinPour

i++

Finttque

tri bulles commentaires
Tri à bulles: Commentaires
  • Complexité en temps : o(n(n-1)/2) ~ o(n2)
  • Mémoire: tableau non dupliqué
tri par s lection 4 que

...

sous-table p

trié

sous-table 1

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
tri par segmentation quicksort
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 [Tj+1, Tn] soit supérieur a Tj

On pivote récursivement sur

[T0,Tj-1] et [Tj+1, Tn].

tri par segmentation quicksort57

seg (0,11)

2 1 2 1 3

seg (0,11)

1 1 2 2 3

seg (0,11)

seg (0,4); seg (4,11)

3 9 5 7 6 8 4

seg (0,4); seg (5,11)

9 5 7 6 8 4

3

seg (0,2); seg(3,4); seg(5,11)

4 5 7 6 8 9

1 1 2

2 3

seg(5,10)

4 5 7 6 8

9

seg(6,10)

5 7 6 8

4

seg(7,10)

7 6 8

5

seg(7,10)

6 7 8

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

tri par segmentation quicksort58
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
conclusion
Conclusion

Fonctionnement d’un programme et d’un 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 qu’une fin en soi.

Bon courage pour vos projets !

references
References
  • Web
  • Aho et al. Structures de donnees et algorithmes, Addisson-Wesley / InterEditions. 1989.
  • Aho et Ullman. Concepts fondamentaux de l’informatique, Dunod. 1993.
  • Sedgewick. Algorithmes en C. Addisson-Wesley / InterEditions. 1991.
annexe pointeurs de fonction
Annexe: Pointeurs de fonction

But : paramétrer des fonctions par d’autres fonctions pour modifier leur actions.

Déclaration :

type (* nom_de_fonction) ([arguments]);

Utilisation :

(* nom_de_fonction) (arg1, arg2, arg3,...);

annexe pointeurs de fonction62
Annexe: Pointeurs de fonction

short tab[10]

short carre( short v ) { return a * a; }

void imprimer(

int nb_elems, short (* function )( short )

) {

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

printf( “%d ”, (* function) ( tab[i] ) );

}

}

int main() {

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

tab[i] = n;

}

imprimer( 10, carre );

}

Retour aux arbres