Python Merge Sort – Algorithmus Implementierung

algorithmes de recommandation

Die Zusammenführungssortierung folgt dem Divide-and-Conquer-Paradigma der Aufteilung der ursprünglichen Aufgabe in zwei ähnliche, kleinere Aufgaben. Dieser Artikel enthält eine Implementierung der Python-Zusammenführungssortierung.

Die Zusammenführungssortierung folgt dem Divide-and-Conquer-Paradigma der Aufteilung der ursprünglichen Aufgabe in zwei ähnliche, kleinere Aufgaben. Dieser Artikel enthält eine Implementierung der Python-Zusammenführungssortierung.

Einführung

Der Algorithmus lautet wie folgt:
Teilen Sie die zu sortierende Liste in zwei Hälften.
Wir sortieren jede von ihnen.
Führen Sie die beiden erhaltenen Hälften zusammen, um die sortierte Liste wiederherzustellen.

Dieser Algorithmus wird rekursiv angewendet, dh bis die zu sortierende Liste aus einem einzelnen Element besteht.

Python-Zusammenführungssortierung Zusammenführungssortierung (Quelle: Wikipedia)

#Tri fusion fonction de division du tableau
def tri_fusion(tableau):
    if  len(tableau) <= 1: 
        return tableau
    pivot = len(tableau)//2
    tableau1 = tableau[:pivot]
    tableau2 = tableau[pivot:]
    gauche = tri_fusion(tableau1)
    droite = tri_fusion(tableau2)
    fusionne = fusion(gauche,droite)
    return fusionne


#Tri fusion fonction de fusion de 2 listes
def fusion(tableau1,tableau2):
    indice_tableau1 = 0
    indice_tableau2 = 0    
    taille_tableau1 = len(tableau1)
    taille_tableau2 = len(tableau2)
    tableau_fusionne = []
    while indice_tableau1<taille_tableau1 and indice_tableau2<taille_tableau2:
        if tableau1[indice_tableau1] < tableau2[indice_tableau2]:
            tableau_fusionne.append(tableau1[indice_tableau1])
            indice_tableau1 += 1
        else:
            tableau_fusionne.append(tableau2[indice_tableau2])
            indice_tableau2 += 1
    while indice_tableau1<taille_tableau1:
        tableau_fusionne.append(tableau1[indice_tableau1])
        indice_tableau1+=1
    while indice_tableau2<taille_tableau2:
        tableau_fusionne.append(tableau2[indice_tableau2])
        indice_tableau2+=1
    return tableau_fusionne

tableau = [11, 222, 3, 899, 24, 5, 46, 67]
print(tableau)
tableau_trie = tri_fusion(tableau)
print(tableau_trie)


# Sortierfunktion für Zusammenführungstabellen sortieren
def tri_fusion (Array):
wenn len (Array) & lt; = 1:
Array zurückgeben
pivot = len (Array) // 2
array1 = array [: pivot]
array2 = array [Pivot:]
left = tri_merging (array1)
rechts = tri_merging (array2)
merge = merge (links, rechts)
Rückführungszusammenführungen Sort Merge-Funktion zum Zusammenführen von 2 Listen def merge (array1, array2):
array_index1 = 0
array_index2 = 0
array_size1 = len (array1)
array_size2 = len (array2)
table_merged = []
während array_index1 & lt; array_size1 und array_index2 & lt; array_size2:
wenn array1 [array_index1] & lt; array2 [array_index2]:
array_merged.append (array1 [array_index1])
index_table1 + = 1
sonst:
array_merged.append (array2 [array_index2])
array_index2 + = 1
während array_index1 & lt; array_size1:
array_merged.append (array1 [array_index1])
index_table1 + = 1
während array_index2 & lt; array_size2:
array_merged.append (array2 [array_index2])
array_index2 + = 1
return merge_array Array = [11, 222, 3, 899, 24, 5, 46, 67]
print (Array)
array_sort = tri_merging (Array)
print (sort_array)


Informationen zur Zusammenführungssortierung

Schließlich funktioniert die Zusammenführungssortierung im Vergleich. Die Komplexität des Algorithmus für n Eingaben ist n log n , also asymptotisch optimal.

Die Technik ist Teilen und Erobern. Der Algorithmus führt hauptsächlich eine Zusammenführungsoperation aus (zwei sortierte Listen können in linearer Zeit zusammengeführt werden).

Python-Zusammenführungssortierung: externe Links

https://www.geeksforgeeks.org/merge-sort/

http://lwh.free.fr/pages/algo/tri/tri_fusion.html
https://pixees.fr/informatiquelycee/n_site/isn_algo_diviser_pour_regner.html

https://fr.wikipedia.org/wiki/Tri_fusion

https://graal.hypotheses.org/tag/algorithme-de-wagner-fischer
https://fr.wikipedia.org/wiki/Algorithme_de_Wagner-Fischer

https://en.wikipedia.org/wiki/Distance_de_Levenshtein

https://medium.com/@sddkal/wagner-fischer-algorithm-be0d96893f6d

https://www.python-course.eu/levenshtein_distance.php

Liens internes sur les algorithmes
https://128mots.com/index.php/2021/01/19/levenshtein-python/
https://128mots.com/index.php/category/python/

https://128mots.com/index.php/category/graphes/
ein https://128mots.com/index.php/2020/02/18/implementation-python-de-lalgorithme-de-dijkstra/ https://128mots.com/index.php/2020/02/17/lalgorithme-de-dijkstra-dans-un-graphe-pondere-et-oriente-en-plus-de-128 -mots / https://128mots.com/index.php/2020/02/17/lalgorithme-de-dijkstra-dans-un-graphe-pondere-et-oriente-en-plus-de-128-mots/
Gießen Sie den Rechner in die Entfernung von Levenshtein mit einem Algorithmus, der nicht rekursiv ist. Bei Verwendung von mat matice qui contient les distance de Levenshtein. Alors Ce sont les Entfernungen entre tous les préfixes de la première chaîne und tous les préfixes de la seconde chaîne de caractères.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *