mirror of
https://github.com/Fare-spec/cours.git
synced 2025-12-08 03:00:37 +00:00
Add university content
This commit is contained in:
282
high-school/trees/AB/arbre.py
Normal file
282
high-school/trees/AB/arbre.py
Normal file
@@ -0,0 +1,282 @@
|
||||
class Arbre_Binaire(object):
|
||||
def __init__(self, racine=None, sag=None, sad=None) -> None:
|
||||
self.racine = racine
|
||||
self.ss_arbre_gauche = sag
|
||||
self.ss_arbre_droit = sad
|
||||
return None
|
||||
|
||||
def est_vide(self):
|
||||
return self.racine is None
|
||||
|
||||
def taille(self):
|
||||
if self.est_vide():
|
||||
return 1
|
||||
else:
|
||||
taille_gauche = self.ss_arbre_gauche.taille() if self.ss_arbre_gauche else 0
|
||||
taille_droite = self.ss_arbre_droit.taille() if self.ss_arbre_droit else 0
|
||||
|
||||
return 1 + taille_gauche + taille_droite
|
||||
|
||||
def hauteur(self):
|
||||
if self.est_vide():
|
||||
return 0
|
||||
else:
|
||||
profondeur_gauche = (
|
||||
self.ss_arbre_gauche.hauteur() if self.ss_arbre_gauche else 0
|
||||
)
|
||||
profondeur_droite = (
|
||||
self.ss_arbre_droit.hauteur() if self.ss_arbre_droit else 0
|
||||
)
|
||||
return 1 + max(profondeur_droite, profondeur_gauche)
|
||||
|
||||
def parcours_largeur(self):
|
||||
if self.est_vide():
|
||||
return None
|
||||
file = [(self, 0)]
|
||||
niveaux = {}
|
||||
while file:
|
||||
noeud, niveau = file.pop(0)
|
||||
if niveau not in niveaux:
|
||||
niveaux[niveau] = []
|
||||
niveaux[niveau].append(noeud.racine)
|
||||
if noeud.ss_arbre_gauche:
|
||||
file.append((noeud.ss_arbre_gauche, niveau + 1))
|
||||
if noeud.ss_arbre_droit:
|
||||
file.append((noeud.ss_arbre_droit, niveau + 1))
|
||||
return niveaux
|
||||
|
||||
|
||||
class Arbre_Binaire_Recherche(Arbre_Binaire):
|
||||
def __init__(self) -> None:
|
||||
self.racine = None
|
||||
self.ss_arbre_droit = None
|
||||
self.ss_arbre_gauche = None
|
||||
|
||||
def insertion(self, element):
|
||||
if self.est_vide():
|
||||
self.racine = element
|
||||
self.ss_arbre_gauche = (
|
||||
Arbre_Binaire_Recherche()
|
||||
) # pour eviter l'erreur NoneType has no attribut 'insertion'
|
||||
self.ss_arbre_droit = Arbre_Binaire_Recherche() # pareil
|
||||
elif element <= self.racine:
|
||||
self.ss_arbre_gauche.insertion(element)
|
||||
else:
|
||||
self.ss_arbre_droit.insertion(element)
|
||||
|
||||
def recherche(self, valeur):
|
||||
if self.est_vide():
|
||||
return False
|
||||
if element == valeur:
|
||||
return True
|
||||
elif element < self.racine:
|
||||
return self.ss_arbre_gauche.recherche(element)
|
||||
else:
|
||||
return self.ss_arbre_droit.recherche(element)
|
||||
|
||||
def ajouter(self, valeur):
|
||||
"""
|
||||
même code qu insertion
|
||||
"""
|
||||
if self.est_vide():
|
||||
self.racine = valeur
|
||||
self.ss_arbre_droit = Arbre_Binaire_Recherche()
|
||||
self.ss_arbre_gauche = Arbre_Binaire_Recherche()
|
||||
elif valeur <= self.racine:
|
||||
self.ss_arbre_gauche.ajouter(valeur)
|
||||
else:
|
||||
self.ss_arbre_droit.ajouter(valeur)
|
||||
|
||||
def mini(self):
|
||||
"""
|
||||
cette fonction sert a trouver le minimum d'un sous arbre on l'utilise notamment pour la suppression d'un noeud dans un arbre contenant des "enfants"...
|
||||
"""
|
||||
a = self
|
||||
while not a.ss_arbre_gauche.est_vide():
|
||||
a = a.ss_arbre_gauche
|
||||
return a.racine
|
||||
|
||||
def supprimer(self, valeur):
|
||||
if self.est_vide():
|
||||
return Arbre_Binaire_Recherche()
|
||||
|
||||
if element < self.racine:
|
||||
self.ss_arbre_gauche = self.ss_arbre_gauche.supprimer(valeur)
|
||||
elif element > self.racine:
|
||||
self.ss_arbre_droit = self.ss_arbre_droit.supprimer(valeur)
|
||||
else:
|
||||
if self.ss_arbre_gauche.est_vide() and self.ss_arbre_droit.est_vide():
|
||||
return Arbre_Binaire_Recherche()
|
||||
elif self.ss_arbre_droit.est_vide():
|
||||
return self.ss_arbre_droit
|
||||
elif self.ss_arbre_gauche.est_vide():
|
||||
return self.ss_arbre_gauche
|
||||
else:
|
||||
next = self.ss_arbre_droit.mini()
|
||||
self.racine = next
|
||||
self.ss_arbre_droit = self.ss_arbre_droit.supprimer(next)
|
||||
|
||||
def abr_vers_liste(self):
|
||||
if self.est_vide():
|
||||
return []
|
||||
|
||||
gauche = self.ss_arbre_gauche.abr_vers_liste() if self.ss_arbre_gauche else []
|
||||
droite = self.ss_arbre_droit.abr_vers_liste() if self.ss_arbre_droit else []
|
||||
|
||||
return gauche + [self.racine] + droite
|
||||
|
||||
|
||||
def affiche(arbre, traitement):
|
||||
if arbre and not arbre.est_vide():
|
||||
if traitement == "prefixe":
|
||||
print(arbre.racine)
|
||||
affiche(arbre.ss_arbre_gauche, "prefixe")
|
||||
if traitement == "infixe":
|
||||
print(arbre.racine)
|
||||
affiche(arbre.ss_arbre_droit, "infixe")
|
||||
if traitement == "postfixe":
|
||||
print(arbre.racine)
|
||||
|
||||
|
||||
def list_to_btree(liste):
|
||||
if not liste:
|
||||
return Arbre_Binaire()
|
||||
else:
|
||||
racine = Arbre_Binaire_Recherche()
|
||||
for elt in liste[1:]:
|
||||
racine.insertion(elt)
|
||||
return racine
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
arbre = Arbre_Binaire(1, Arbre_Binaire(2), Arbre_Binaire(3))
|
||||
print("taille arbre :", arbre.taille())
|
||||
print("hauteur arbre :", arbre.hauteur())
|
||||
|
||||
liste = [18, 11, 19, 73, 12, 1, 20, 5, 23, 8, 10, 29]
|
||||
arbre = list_to_btree(liste)
|
||||
affiche(arbre, "prefixe")
|
||||
liste1 = arbre.abr_vers_liste()
|
||||
print(
|
||||
liste1
|
||||
) # on observer que la liste devient triée (logique car on la trie pour la mettre dans l'arbre et on ne peut pas la recupérer comme si elle ne l'etait pas)
|
||||
|
||||
tas = [1, 5, 8, 10, 11, 12, 18, 19, 20, 23, 29, 73]
|
||||
|
||||
|
||||
def ajouter(tas, element):
|
||||
tas.append(element)
|
||||
i = len(tas) - 1
|
||||
|
||||
while i > 0:
|
||||
parent = (i - 1) // 2
|
||||
if tas[i] < tas[parent]:
|
||||
tas[i], tas[parent] = tas[parent], tas[i]
|
||||
i = parent
|
||||
else:
|
||||
break
|
||||
|
||||
|
||||
# nlog(n)
|
||||
class Tas_Max(object):
|
||||
@staticmethod
|
||||
def parent(i):
|
||||
return (i - 1) // 2
|
||||
|
||||
@staticmethod
|
||||
def enfant_gauche(i):
|
||||
return 2 * i + 1
|
||||
|
||||
@staticmethod
|
||||
def enfant_droite(i):
|
||||
return 2 * i + 2
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.elements = list()
|
||||
self.taille = 0
|
||||
|
||||
def existe_enfant_gauche(self, i):
|
||||
return 2 * i + 1 < self.taille
|
||||
|
||||
def existe_enfant_droit(self, i):
|
||||
return 2 * i + 2 < self.taille
|
||||
|
||||
def tamiser(self, racine):
|
||||
while racine > 0 and self.elements[racine] > self.elements[parent(raicne)]:
|
||||
self.elements[racine], self.element[parent(racine)] = (
|
||||
self.elements[parent(racine)],
|
||||
self.elements[racine],
|
||||
)
|
||||
|
||||
def ratisser(self, racine):
|
||||
courant = racine
|
||||
if (
|
||||
self.existe_enfant_gauche(racine)
|
||||
and self.elements[enfant_gauche(racine)] > self.element[racine]
|
||||
):
|
||||
courant = enfant_gauche(racine)
|
||||
if (
|
||||
self.existe_enfant_droit(racine)
|
||||
and self.elements[enfant_droit(racine)] > self.elements[courant]
|
||||
):
|
||||
courant = enfant_droit(racine)
|
||||
if courant != racine:
|
||||
self.elements[racine], self.elements[courant] = (
|
||||
self.elements[courant],
|
||||
self.elements[racine],
|
||||
)
|
||||
|
||||
def ajouter(self, element):
|
||||
self.elements.append(element)
|
||||
self.taille += 1
|
||||
self.tamiser(self.taille)
|
||||
return None
|
||||
|
||||
def extraire_racine(self):
|
||||
if self.taille == 0:
|
||||
return None
|
||||
racine = self.elements[0]
|
||||
if self.taille > 0:
|
||||
self.elements[0] = self.elements.pop()
|
||||
self.ratisser(0)
|
||||
else:
|
||||
self.elements.pop()
|
||||
return racine
|
||||
|
||||
|
||||
def liste_vers_tas_max(liste):
|
||||
tas = Tas_Max()
|
||||
for i in liste:
|
||||
tas.ajouter(i)
|
||||
return tas
|
||||
|
||||
|
||||
def tas_max_vers_liste(tas):
|
||||
resultat = []
|
||||
while tas.taille > 0:
|
||||
resultat.append(tas.extraire_racine())
|
||||
return resultat
|
||||
|
||||
|
||||
def convertir_liste_en_tas(liste):
|
||||
def ratisser(elements, taille, i):
|
||||
plus_grand = i
|
||||
g = 2 * i + 1
|
||||
d = 2 * i + 2
|
||||
|
||||
if g < taille and elements[g] > elements[plus_grand]:
|
||||
plus_grand = g
|
||||
if d < taille and elements[d] > elements[plus_grand]:
|
||||
plus_grand = d
|
||||
if plus_grand != i:
|
||||
elements[i], elements[plus_grand] = elements[plus_grand], elements[i]
|
||||
ratisser(elements, taille, plus_grand)
|
||||
|
||||
n = len(liste)
|
||||
for i in range(n // 2 - 1, -1, -1):
|
||||
ratisser(liste, n, i)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
l1 = [1, 2, 3, 8, 7, 6, 5, 4]
|
||||
tas = liste_vers_tas_max(l1)
|
||||
0
high-school/trees/ABR/main.py
Normal file
0
high-school/trees/ABR/main.py
Normal file
File diff suppressed because one or more lines are too long
18
high-school/trees/genealogie/genealogie.csv
Normal file
18
high-school/trees/genealogie/genealogie.csv
Normal file
@@ -0,0 +1,18 @@
|
||||
'Henri IV' ; 1553 ; 1610 ; '1589-1610' ; 1
|
||||
'Louis XIII' ; 1601 ; 1643 ; '1610-1643' ; 2, 3
|
||||
'Louis XIV' ; 1638 ; 1715 ; '1643-1715' ; 4
|
||||
'Philippe Ier, duc d'Orleans' ; 1640 ; 1701 ; '' ; 15
|
||||
'Louis le Grand Dauphin' ; 1661 ; 1711 ; '' ; 5, 6
|
||||
'Louis, duc de Bourgogne' ; 1682 ; 1712 ; '' ; 7
|
||||
'Philippe V, roi d'Espagne' ; 1683 ; 1746 ; '' ;
|
||||
'Louis XV' ; 1710 ; 1774 ; '1715-1774' ; 8
|
||||
'Louis, Dauphin' ; 1729 ; 1765 ; '' ; 9, 10, 11
|
||||
'Louis XVI' ; 1754 ; 1793 ; '1754-1793' ; 13
|
||||
'Louis XVIII' ; 1755 ; 1824 ; '1815-1824' ;
|
||||
'Charles X' ; 1756 ; 1832 ; '1824-1830' ;
|
||||
'Louis-Philippe-Joseph "Philippe Egalite"' ; 1747 ; 1793 ; '' ; 14
|
||||
'Louis XVII' ; 1785 ; 1795 ; '' ;
|
||||
'Louis-Philippe Ier, roi des Français' ; 1773 ; 1850 ; '' ;
|
||||
'Philippe II' ; 1674 ; 1723 ; '' ; 16
|
||||
'Louis, duc d'Orleans' ; 1703 ; 1752 ; '' ; 17
|
||||
'Louis-Philippe Ier, duc d'Orleans' ; 1725 ; 1785 ; '' ; 12
|
||||
|
Can't render this file because it contains an unexpected character in line 13 and column 25.
|
132
high-school/trees/genealogie/genealogie.py
Normal file
132
high-school/trees/genealogie/genealogie.py
Normal file
@@ -0,0 +1,132 @@
|
||||
Genealogie = [
|
||||
["Henri IV", 1553, 1610, "1589-1610", [1]],
|
||||
["Louis XIII", 1601, 1643, "1610-1643", [2, 3]],
|
||||
["Louis XIV", 1638, 1715, "1643-1715", [4]],
|
||||
["Philippe Ier, duc d'Orleans", 1640, 1701, "", [15]],
|
||||
["Louis le Grand Dauphin", 1661, 1711, "", [5, 6]],
|
||||
["Louis, duc de Bourgogne", 1682, 1712, "", [7]],
|
||||
["Philippe V, roi d'Espagne", 1683, 1746, "", []],
|
||||
["Louis XV", 1710, 1774, "1715-1774", [8]],
|
||||
["Louis, Dauphin", 1729, 1765, "", [9, 10, 11]],
|
||||
["Louis XVI", 1754, 1793, "1754-1793", [13]],
|
||||
["Louis XVIII", 1755, 1824, "1815-1824", []],
|
||||
["Charles X", 1756, 1832, "1824-1830", []],
|
||||
['Louis-Philippe-Joseph "Philippe Egalite"', 1747, 1793, "", [14]],
|
||||
["Louis XVII", 1785, 1795, "", []],
|
||||
["Louis-Philippe Ier, roi des Français", 1773, 1850, "", []],
|
||||
["Philippe II", 1674, 1723, "", [16]],
|
||||
["Louis, duc d'Orleans", 1703, 1752, "", [17]],
|
||||
["Louis-Philippe Ier, duc d'Orleans", 1725, 1785, "", [12]],
|
||||
]
|
||||
|
||||
|
||||
def creer_arbre():
|
||||
return ()
|
||||
|
||||
|
||||
def est_vide(arbre):
|
||||
return arbre == () or arbre is None
|
||||
|
||||
|
||||
def rechercher(arbre, valeur):
|
||||
if not (est_vide(arbre)):
|
||||
racine, enfants = arbre
|
||||
if racine == valeur:
|
||||
return arbre
|
||||
resultat = creer_arbre()
|
||||
for ss_arbre in enfants:
|
||||
resultat = rechercher(ss_arbre, valeur)
|
||||
if not (est_vide(resultat)):
|
||||
break
|
||||
return resultat
|
||||
return arbre
|
||||
|
||||
|
||||
def ajouter_enfant(arbre, enfant, cle_parent):
|
||||
if est_vide(arbre):
|
||||
return enfant
|
||||
return arbre.insert(cle_parent + 1, enfant)
|
||||
|
||||
|
||||
Bourbons = [
|
||||
["Nom", "naissance", "mort", "règne"],
|
||||
["Henri IV", 1553, 1610, "1589-1610"],
|
||||
["Louis XIII", 1601, 1643, "1610-1643"],
|
||||
["Louis XIV", 1638, 1715, "1643-1715"],
|
||||
["Philippe, duc d'Orleans", 1640, 1701, ""],
|
||||
["Louis le Grand Dauphin", 1661, 1711, ""],
|
||||
["Louis, duc de Bourgogne", 1682, 1712, ""],
|
||||
["Philippe V, roi d'Espagne", 1683, 1746],
|
||||
["Louis XV", 1710, 1774, "1715-1774"],
|
||||
["Louis, Dauphin", 1729, 1765, ""],
|
||||
["Louis XVI", 1754, 1793, "1765-1792"],
|
||||
["Louis XVIII", 1755, 1824, "1814-1824"],
|
||||
["Charles X", 1756, 1832, "1824-1830"],
|
||||
['Louis-Philippe-Joseph "Philippe Egalite"', 1747, 1793, ""],
|
||||
["Louis XVII", 1785, 1795, ""],
|
||||
["Louis Philippe Ier", 1773, 1850, "1830-1848"],
|
||||
]
|
||||
|
||||
Genealogie = (
|
||||
1,
|
||||
[
|
||||
(
|
||||
2,
|
||||
[
|
||||
(
|
||||
3,
|
||||
[
|
||||
(
|
||||
5,
|
||||
[
|
||||
(6, [(8, [(9, [(10, [14]), (11, []), (12, [])])])]),
|
||||
(7, []),
|
||||
],
|
||||
)
|
||||
],
|
||||
),
|
||||
(4, []),
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
print("ENUMERATION :")
|
||||
for rg, bourbon in enumerate(Bourbons):
|
||||
print(rg, bourbon[0])
|
||||
print()
|
||||
print("RECHERCHE :")
|
||||
print(rechercher(Genealogie, 8))
|
||||
|
||||
|
||||
class Arbre(object):
|
||||
def __init__(self, racine=None, ss_arbres=[]) -> None:
|
||||
self.racine = racine
|
||||
self.ss_arbres = ss_arbres
|
||||
|
||||
def est_vide(self):
|
||||
return self.racine == None
|
||||
|
||||
def rechercher(self, valeur):
|
||||
if not (self.est_vide()):
|
||||
if self.racine == valeur:
|
||||
return self
|
||||
resultat = Arbre()
|
||||
for ss_arbre in self.ss_arbres:
|
||||
ss_arbre = Arbre(racine=None, ss_arbres=ss_arbre)
|
||||
resultat = ss_arbre.rechercher(valeur)
|
||||
if not (resultat == None):
|
||||
break
|
||||
return resultat
|
||||
return Arbre()
|
||||
|
||||
def ajouter(self, elt):
|
||||
if self.est_vide():
|
||||
return Arbre(racine=elt)
|
||||
else:
|
||||
return Arbre(elt, self)
|
||||
|
||||
def enlever(self, elt):
|
||||
pass
|
||||
|
||||
def display(self):
|
||||
pass
|
||||
25
high-school/trees/qdj.py
Normal file
25
high-school/trees/qdj.py
Normal file
@@ -0,0 +1,25 @@
|
||||
def calcul_taille(arbre, sommet):
|
||||
reste = True
|
||||
i = 0
|
||||
while reste:
|
||||
if arbre[sommet].voisin_gauche():
|
||||
sommet = arbre[sommet].voisin_gauche()
|
||||
i += 1
|
||||
elif arbre[sommet].voisin_droite():
|
||||
sommet = arbre[sommet].voisin_droite()
|
||||
i += 1
|
||||
return i
|
||||
|
||||
|
||||
def correction(arbre):
|
||||
if arbre.est_vide():
|
||||
return 0
|
||||
else:
|
||||
return 1 + correction(arbre.gauche()) + correction(arbre.droite())
|
||||
|
||||
|
||||
def hauteur(arbre):
|
||||
if arbre.est_vide():
|
||||
return -1
|
||||
else:
|
||||
return max([arbre.droite(), arbre.gauche()])
|
||||
Reference in New Issue
Block a user