Structures des données

Les structures des données permettent de stocker des données temporairement dans la mémoire
centrale durant l’exécution d’un programme.
Dans ce chapitre, on va aborder deux types de structures de données :
Linéaire : liste, Pile, File, Liste simplement chaînée et doublement chaînées.
Non Linéaire : arbres , graphes.

1 Recherche dichotomique
Pour rechercher un nombre dans un tableau ou liste triés par ordre croissant, le principe de
dichotomie consiste à couper ce tableau en deux, à chercher dans une partie et si ce n’est dans
celle-ci, alors nous cherchons dans l’autre et ainsi de suite jusqu’à la fin. Nous nous arrêtons
quand la valeur a été trouvée ou bien lorsque nous sommes arrivé à la fin du tableau c.à.d.
quand la valeur recherchée n’est pas dans le tableau.
Exercice :
Écrire le programme en python.

2 Algorithmes de tris dans un tableau

Les algorithmes de tris consiste à trier un tableau ou liste dans un ordre croissant. Il existe
plusieurs algorithmes de tris parmi lesquels :
Tri par sélection : Il s’agit de trier un tableau de valeur numérique de dimension n par ordre
croissant. Pour ce tri, on cherche le minimum du tableau et on le place au début, puis on
recommence avec le tableau de dimension n-1 qui reste et ainsi de suite.
Tri par insertion : Pour ce tri, à chaque étape on insère l’élément T[i] dans le tableau T[0,
... i-1] qui a été déjà trié de la mème manière.
Tri à bulles : Il consiste à comparer répétitivement les éléments consécutifs d’un tableau, et à
les permuter lorsqu’ils sont mal triés. Il doit son nom au fait qu’il déplace rapidement les plus
grands éléments en fin de tableau, comme des bulles d’air qui remonteraient rapidement à la
surface d’un liquide.

Exercice : Écrivez en Python le programme correspondant à chacun des tris précédents.

3 Les piles
Une pile c’est une structure qui suit le principe du dernier arrivé premier servi, en anglais
Last In First Out (LIFO). En Python, on peut implémenter une pile en utilisant une liste de
taille fixe.

dans une pile deux opération sont autorisée :

Empiler : insérer un élément en haut si la pile n’est pas pleine.
Dépiler : Enlever le dernier élément insérer si la pile n’est pas vide.

1
 ...
...
...
...
→
Top = -1
...
13
9
2

3.1 Implémentation d’une pile à n éléments

taille= 5
pile=[]
tpos = -1
def push(item) :
global tpos
global taille
global pile
if tpos == taille - 1 :
print("Pile pleine")
else :
tpos = tpos + 1
pile= pile+ [item]

def pop() :
global tpos
if tpos==-1 :
print("Pile vide")
item = None
else :
item = pile[tpos]
tpos= tpos-1
return item
Exercice 1 : Créer une pile avec une taille non limitée
Exercice 2 : Utiliser la notion de piles pour renverser texte entrer au clavier.

4 Les Files
Une file est une structure qui suit le principe du premier arrivé premier servi, en anglais
First In First Out (FIFO). En Python, on peut implémenter une Pile en utilisant une liste de
taille fixe.
Une file est caractérisée par une tête et une queue. le nouvel élément est toujours inséré à la
queue et on ne peut supprimé que l’élément qui se trouve à la tête.
Opération sur une files :
Enfiler : insérer un élément. Défiler : supprimé un élément.

2
4.1 Implémentation d’une file avec une liste
On va utiliser une liste pour stocker les éléments de la file.
Initialement la file est vide : queue = tete = −1
Lorsqu’on enfile un nouveau élément on incrémente queue, si queue! = n − 1.
Lorsqu’on défile un élément, on incrémente tete si queu! = −1.
Pour la première effilement, queue et tete sont toutes les deux incrémentées et valent 0.
Dans le cas où queue = tete, si on supprime un élément, alors queue = tete = −1

queue=tete=-1
listeQueue=[]
taille=10
def push(element) :
global listeQueue
global queue
global tete
if queue== taille-1 :
print("File pleine")
elif queue==tete==-1 :
listeQueue = listeQueue + [element]
queue =tete= 0
else :
listeQueue = listeQueue + [element]
queue+=1

def pop() :
global listeQueue
global queue
global tete
if tete==-1 :
return None
elif tete==queue :
item = listeQueue[0]
tete=queue = -1
listeQueue=[]
return item
else :
item = listeQueue[0]
listeQueue = listeQueue[1 : queue-tete + 1]
tete += 1
return item

5 Listes chaînées
5.1 Listes chaînées simple
c’est une collection de nœuds dans laquelle chaque nœud contient la donnée et une référence
de l"élément suivant.

3
5.2 Implémentation d’une liste chaînée simple.
Classe node avec un constructeur pour créer des nœud avec deux attribues :
data : représente la valeur stocké dans le nœud.
next : représente la référence de l’élément suivant. Par défaut, next est nulle.
Classe linkedList représente chaîne un attribue head est la tête de la liste chaînée simple
construteur,
Ajouter à la fin
Ajouter au début,
Ajouter après un élément de la liste
Ajouter avant un élément de la liste
chercher un élément
Modifier un élément
Supprimer un élément

class node :
def __init__(self,data,next=None) :
self.data = data
self.next = next
class linkedlist :
def __init__(self) :
self.head=None
# Ajouter à la fin de la liste.
def addelement(self, data) :
newEle = node(data)
if self.head != None :
curent= self.head
while curent.next !=None :
curent=curent.next
curent.next=newEle
else :
self.head = newEle
# Ajouter un nœud après un élément donné
def addafter(self,data,ele) :
newEle = node(data)
if ele == None :
pass
elif self.head != None :
curent = self.head
while curent.next != None :
if curent == ele :
break
curent = curent.next
newEle.next = curent.next
curent.next = newEle
else :
self.head = newEle

# Ajouter un noeud avant un élément donné.

def addBefor(self, data, ele) :
newEle=node(data)

4
 if ele== None :
pass
elif self.head == None :
self.head=newEle
elif ele == self.head :
newEle.next=self.head
self.head=newEle
else :
curent=self.head
previous=self.head
while curent :
if curent.next == ele :
break
previous =curent
curent=curent.next
newEle.next=curent
previous.next= newEle
# Supprimer un élément.
def delet(self, ele) :
if ele == None :
pass
elif self.head == None :
pass
elif self.head==ele :
self.head=self.head.next
else :
curent=self.head.next
previous=self.head
while curent != ele and curent.next :
previous= previous.next
curent = curent.next
if curent==ele :
previous.next=curent.next
curent.next=None
# Mettre à jour d’une valeur d’un element donnée.
def update(self,newData, ele) :
if not (ele and self.head) :
pass
else :
curent = self.head
while curent.next and curent !=ele :
curent=curent.next
if curent==ele :
curent.data=newData

5.2.1 Implémentation d’une pile à l’aide d’une liste chaînée

class node :
def __init__(self,data,next=None) :

5
 self.data = data
self.next = next
class pile :
def __init__(self) :
self.top= None
def push(self, data) :
newEle=node(data, None)
newEle.next =self.top
self.top= newEle
def pop(self) :
if not self.top :
raise Exception("La pile est vide")
rst=self.top
self.top = self.top.next
return rst
def showPile(self) :
curent =self.top
while curent :
print(curent.data)
curent = curent.next

5.2.2 Implémentation d’une file à l’aide d’une liste chaînée

class node :
def __init__(self, data) :
self.data= data
self.next=None
class queue :
def__init__(self) :
self.front = None
self.rear = None
def push(self, data) :
e=node(data)
if not (self.front or self.rear) :
self.front=self.rear=e
else :
self.rear.next= e
self.rear=e
def pop(self) :
if not self.front :
return None
elif self.front==self.rear :
temp= self.front
self.front = self.rear= None
return temp
else :
temp=self.front
self.front=self.front.next
return temp

6
5.3 Listes doublement chinées
C’est une collection de nœuds dans laquelle chaque nœud contient la donnée, une référence
de L’élément suivant et une référence de l’élément précédent.

Exercice : En suivant les même techniques utiliser précédemment, implémenter une liste
doublement chaînée.

5.4 La structures de données arbre

Un arbre est un ensemble organisé de nœuds dans lequel chaque nœud a un père et un seul
sauf un nœud que l’on appelle racine.
un nœud contient une valeur, une clé ou une étiquette.
un nœud f est appelé un fils d’un nœud p, si p est un nœud de f .
un nœud qui n’a pas de fils est appelé feuille.
Le schéma < e, a1 , a2 , ..., an ) > représente l’arbre de racine le nœud qui a la valeur e est de
sous arbres a1 , a2 , ..., an

5.4.1 Arbre binaire

Un arbre binaire est distingué par le fait que chaque nœud a un fils gauche et un fils droit.
l’un comme l’autre peut être vide.
Un arbre binaire est donc représenté par : < e, aagauche , aadroit >
Exemples : Arbre binaire arithmétique.
a. L’opération 2*3 peut être représentée par l’arbre binaire : < ∗, < 2 >, < 3 >>
b. L’expression (2*x+1)*(z/3-5) :
< ∗, < +, < ∗, < 2 >, < x >>, < 1 >>, < −, < /, < z >, < 2 >>, < 5 >>>.
Il existe plusieurs manière de parcourir et afficher les nœuds d’un arbre binaire : préfixe, infixe,
postfixe, en profoneur, en largeur et autres...

5.4.2 Arbre binaire de recherche

Dans un arbre binaire de recherche on insere des données ordonnées. Si le noeud contient
une donnée plus grande que la donnée de la racine, il est insérée dans le sous arbre à droite
sinon il est insérée à gauche.

5.5 implémentation d’un arbre binaire à l’aide de la bibliothèque any-

tree
Installer la bibliothèque "anytree " par la commande :
pip install anytree
Exemple
from anytree import Node, RenderTree
root = Node(10)
level1child1 = Node(34, parent=root)
level1child2 = Node(89, parent=root)
level2child1 = Node(45, parent=level1child1)

7
level2child2 = Node(50, parent=level1child2)

for pre, fill, node in RenderTree(root) :

print(f"pre , node.name")