typo de part et d'autres
This commit is contained in:
@@ -10,7 +10,7 @@ Il faut aider Jean-Michel à remettre les crêpes dans le bon ordre !
|
||||
|
||||
Pour cela, il va nous falloir :
|
||||
|
||||
- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeller le professeur.
|
||||
- Télécharger le fichier [java](crepe-applet1-jnlp.jnlp) et l'exécuter. Si cela ne fonctionne pas, appeler le professeur.
|
||||
- Prendre son temps et comprendre comment cela fonctionne.
|
||||
- Mettre en place nos idées.
|
||||
- Retourner les crêpes !
|
||||
@@ -59,7 +59,7 @@ En commençant avec six (6) crêpes, je peux donc facilement m'en sortir, voilà
|
||||
|
||||
<img src="assets/étape_2.png" alt="étape_2" style="zoom:50%;" />
|
||||
|
||||
- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crepe la plus large qui est en haut, et la crêpe qui se retrouve en bas.
|
||||
- On retourne le tout en cliquant sur la crêpe du bas pour inverser la position entre la crêpe la plus large qui est en haut, et la crêpe qui se retrouve en bas.
|
||||
|
||||
<img src="assets/étape_3.png" alt="étape_3" style="zoom:50%;" />
|
||||
|
||||
|
||||
@@ -24,9 +24,9 @@ Supposons un tableau tab :
|
||||
tab = [1,2,6,9,12,14,18,21,42]
|
||||
```
|
||||
|
||||
Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en colparant chaque valeur à l'élèment recherché.
|
||||
Si on souhaite chercher un élèment, par exemple 7, en utilisant le [parcours séquentiel](PARCOURS.md) on fonctionne par balayage (avec une boucle for...) et donc parcourir la liste du début à la fin en comparant chaque valeur à l'élèment recherché.
|
||||
|
||||
Ici par exemple, on effectuerait 9 comparaison pour finir par dire que non, 7 n'est pas présent.
|
||||
Ici par exemple, on effectuerait 9 comparaisons pour finir par dire que non, 7 n'est pas présent.
|
||||
|
||||
Dans le cas d'une liste **déjà triée**, la recherche dichotomique permet d'améliorer les performances.
|
||||
|
||||
@@ -60,13 +60,13 @@ Montrer le nombre d'étapes nécessaires à la réussite de cette recherche.
|
||||
| Recherche Dichotomique | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | log<sub>2</sub>N |
|
||||
|
||||
- Quel est le pire des cas ici ? Que l'élèment recherché ne soit pas dans le tableau.
|
||||
- Le nombre de tours de boucle de la recherche dichotomique est de l'ordrede log<sub>2</sub>(n) où *n* est la taille de la liste.
|
||||
- Le nombre de tours de boucle de la recherche dichotomique est de l'ordre de log<sub>2</sub>(n) où *n* est la taille de la liste.
|
||||
|
||||
*Explications*
|
||||
|
||||
Qu'est ce que le ***Logarithme***:
|
||||
|
||||
pour faire simple, le logarithme en base n - écrit log<sub>n</sub> correspond au nombre de division par n successive pour arriver au nombre 0.
|
||||
pour faire simple, le logarithme en base n - écrit log<sub>n</sub> correspond au nombre de divisions par n successives pour arriver au nombre 1.
|
||||
|
||||
***Exemple :***
|
||||
|
||||
@@ -110,27 +110,25 @@ La recherche dichotomique est donc de complexité ***logarithmique***.
|
||||
|
||||
Pour vérifier que la recherche dichotomique se termine bien, regardons ensemble son code python - on suppose que le tableau en entrée est déjà trié.
|
||||
|
||||
````python
|
||||
def dichotomique (tab, x):
|
||||
"""
|
||||
:param tab: tableau contenant différents élèments déjà triés
|
||||
:param x: élèment recherché
|
||||
"""
|
||||
a = 0 # on initialise la borne inférieure
|
||||
b = len(tab) - 1 # borne supérieure
|
||||
while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure
|
||||
m = (a + b) // 2 # on se place au milieu du tableau
|
||||
if tab[m] == x: # si l'élément central est l'élément recherché
|
||||
return True # alors on a terminé
|
||||
elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché
|
||||
a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau
|
||||
else: #si l'élement central n'est ni plus petit ni égal à l'élément recherché, donc s'il est >...
|
||||
b = m - 1 #on déplace la borne supérieure vers la sous-partie gauche
|
||||
#si après tout ça on ne trouve pas l'élément...
|
||||
return False
|
||||
|
||||
|
||||
````
|
||||
```python
|
||||
def dichotomique(tab, x):
|
||||
"""
|
||||
:param tab: tableau contenant différents élèments déjà triés
|
||||
:param x: élèment recherché
|
||||
"""
|
||||
a = 0 # on initialise la borne inférieure
|
||||
b = len(tab) - 1 # borne supérieure
|
||||
while a <= b: # tant que la borne inférieure est plus petite ou égale à la borne supérieure
|
||||
m = (a + b) // 2 # on se place au milieu du tableau
|
||||
if tab[m] == x: # si l'élément central est l'élément recherché
|
||||
return True # alors on a terminé
|
||||
elif tab[m] < x: # si l'élément central est plus petit que l'élément recherché
|
||||
a = m + 1 # on déplace la borne minimum vers la sous-partie droite du tableau
|
||||
else: # si l'élément central est plus grand que l'élément recherché
|
||||
b = m - 1 # on déplace la borne supérieure vers la sous-partie gauche
|
||||
# si après tout ça on ne trouve pas l'élément...
|
||||
return False
|
||||
```
|
||||
|
||||
-----------
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ On supposera que tous les tableaux traités ici contiennent des nombres.
|
||||
|
||||
### Exemples
|
||||
|
||||
#### Recherche d'occurence
|
||||
#### Recherche d'occurrence
|
||||
|
||||
Si on souhaite savoir si un élément nommé *e* en particulier se trouve dans un tableau *tab* :
|
||||
|
||||
@@ -56,7 +56,7 @@ def recherche_max(tab):
|
||||
|
||||
*Complexité linéaire*
|
||||
|
||||
Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
|
||||
Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons.
|
||||
|
||||
--------
|
||||
|
||||
@@ -73,13 +73,13 @@ def moyenne(tab):
|
||||
|
||||
*Complexité linéaire*
|
||||
|
||||
Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
|
||||
Car on parcourt toute la liste et donc pour n élèments, on effectuera n comparaisons.
|
||||
|
||||
-----------
|
||||
|
||||
#### Autres exemples simples :
|
||||
|
||||
- Vérifier si une un tableau est rangé par ordre croissant ou décroissant
|
||||
- Vérifier si un tableau est rangé par ordre croissant ou décroissant
|
||||
- Chercher un mot de plus de n lettres dans une liste de mots...
|
||||
|
||||
--------
|
||||
|
||||
@@ -41,8 +41,8 @@ $$
|
||||
|
||||
- La **complexité d'un algorithme** est une mesure du temps requis par l'algorithme pour accomplir sa tâche, en fonction de la taille des données à traiter.
|
||||
- On dira d'un problème qu'il est aussi complexe que le meilleur algorithme connu pour le résoudre.
|
||||
- Si la **complexité** est **constante**, alors le temps d'execution sera sensiblement toujours le même, peu importe la taille du tableau traité.
|
||||
- Si elle est **logarithmique**, alors le temps d'execution augmente très faiblement quand le paramètre croit.
|
||||
- Si la **complexité** est **constante**, alors le temps d'exécution sera sensiblement toujours le même, peu importe la taille du tableau traité.
|
||||
- Si elle est **logarithmique**, alors le temps d'exécution augmente très faiblement quand le paramètre croît.
|
||||
- **Complexité** **linéaire** : le nombre d'étapes à effectuer va varier en proportion directe de la taille de l'échantillon à traiter : si l'échantillon croît par un facteur de 10000, la complexité sera accrue elle aussi par un facteur de 10000.
|
||||
- **Complexité Quadratique** : Dans le cadre du tri par insertion, par exemple, quand on double la taille du tableau, le nombre de comparaisons sera lui multiplié par...4.
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ Un algorithme est une séquence finie d’instructions faite pour être exécut
|
||||
|
||||
- Logique parce que la personne (ou la machine) qui exécute les instructions sera capable de facilement comprendre et exécuter sans erreur ni ambigüité chacune des instructions.
|
||||
|
||||
- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir a comprendre la méthode de solution.
|
||||
- Non intelligente parce que la personne qui exécute l’algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre pour arriver au résultat sans avoir à comprendre la méthode de solution.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -101,7 +101,7 @@ Le tri par insertion est *naturel* dans l'esprit : on parcourt le tableau de la
|
||||
|
||||
Une preuve de correction de l'algorithme est la propriété *p(i)* : "le tableau est trié jusqu'à la case n°i" : cette propriété est vraie **avant** et **après** chaque tour de boucle : c'est ce qu'on appelle ***Invariant de boucle***
|
||||
|
||||
À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taile de la liste restante à trier.
|
||||
À l'inverse, le **variant** de boucle est une expression dans la valeur varie à chaque tour de boucle et qui doit justement permettre de mettre fin à la-dite boucle : le variant d'un algorithme de tri sera alors la taille de la liste restante à trier.
|
||||
|
||||
### Complexité
|
||||
|
||||
@@ -119,9 +119,9 @@ Merci @https://x.com/Limplementeur pour l'illustration
|
||||
|
||||
-----------------
|
||||
|
||||
## Tri par selection
|
||||
## Tri par sélection
|
||||
|
||||
> Contrairement au tri par insertion, le tri par selection a pour avantage de déplacer moins de valeurs.
|
||||
> Contrairement au tri par insertion, le tri par sélection a pour avantage de déplacer moins de valeurs.
|
||||
|
||||
|
||||
|
||||
@@ -130,7 +130,7 @@ Principe:
|
||||
- On recherche le plus petit élément et on le met à sa place (indice 0 donc)
|
||||
- Puis on recherche le deuxième plus petit et on le met à l'indice 1
|
||||
- Et on continue comme cela avec tous les éléments
|
||||
- Il n'est pas necessaire de faire une copie de la liste
|
||||
- Il n'est pas nécessaire de faire une copie de la liste
|
||||
- Deux éléments égaux ne resteront pas forcément à la même place
|
||||
|
||||
Supposons le tableau suivant :
|
||||
@@ -186,7 +186,7 @@ Il faut montrer l'invariant : à la fin du tour i de la boucle for, les cases ta
|
||||
|
||||
#### Exercices
|
||||
|
||||
- Ecrire les fonctions
|
||||
- Écrire les fonctions
|
||||
|
||||
```python
|
||||
tri_selection (tab)
|
||||
@@ -198,7 +198,7 @@ et
|
||||
tri_insertion(tab)
|
||||
```
|
||||
|
||||
qui permettent de trier différement les tableaux donnés en entrée.
|
||||
qui permettent de trier différemment les tableaux donnés en entrée.
|
||||
|
||||
Expliquer pourquoi ces algorithmes sont en O(n<sup>2</sup> ) avec vos propres mots.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user