Structure des données: algorithme de tri commun (huit): tri par fusion (implémentation C ++)

Structure des données: algorithme de tri commun (8): tri par fusion

(1) Idée de base:

La méthode de tri par fusion (fusion) consiste à fusionner deux (ou plus) listes ordonnées en une nouvelle liste ordonnée, c'est-à-dire à diviser la séquence à trier en plusieurs sous-séquences, et chaque sous-séquence est ordonnée. Ensuite, les sous-séquences ordonnées sont fusionnées dans la séquence ordonnée globale. Dans la deuxième étape du tri par fusion, la règle de tri de deux tableaux ordonnés est très simple. Dans le même temps, comparez la taille de la première position des deux tableaux, placez la plus petite dans un tableau vide, puis placez la position dans le tableau vide. Le pointeur recule d'un, puis continue à comparer avec la position précédente d'un autre tableau, et ainsi de suite. Jusqu'à ce que l'un des derniers tableaux soit sorti de la pile en premier, tous les éléments de l'autre tableau sont ajoutés au nouveau tableau.

Le tri par fusion et le tri rapide ont le même effet. Tri rapide: commencez par trier grossièrement le tableau en deux sous-tableaux, puis divisez-le de manière récursive en deux sous-tableaux jusqu'à ce qu'il n'y ait qu'un seul élément dans le sous-tableau, puis il sera trié naturellement Il peut être résumé comme un tri d'abord, puis récursif; tri par fusion: Quoi qu'il en soit, le tableau est divisé en deux sous-tableaux et le tableau est divisé en deux sous-tableaux de manière récursive, jusqu'à ce qu'il n'y ait qu'un seul élément dans le tableau, puis le tri commence. Triez les deux tableaux dans l'ordre et triez les deux tableaux l'un après l'autre selon le retour récursif. À la fin, vous pouvez trier le tableau entier.

(2) Exemples

Exemple: a [15] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48} Trier par tri par fusion

img

2.1 Méthode itérative

① Appliquer un espace pour faire de la taille la somme de deux séquences triées, cet espace est utilisé pour stocker la séquence fusionnée

② Définissez deux pointeurs, les positions initiales sont respectivement les positions de départ des deux séquences triées

③ Comparez les éléments pointés par les deux pointeurs, sélectionnez un élément relativement petit à placer dans l'espace de fusion et déplacez le pointeur vers la position suivante

④ Répétez l'étape ③ jusqu'à ce qu'un pointeur atteigne la fin de la séquence

⑤ Copiez tous les éléments restants d'une autre séquence directement à la fin de la séquence fusionnée

2.2 Récursivité

① Fusionner tous les deux nombres adjacents dans la séquence pour former des séquences d'étage (n / 2). Après le tri, chaque séquence contient deux éléments

② Fusionnez à nouveau les séquences ci-dessus pour former des séquences de plancher (n / 4), chaque séquence contient quatre éléments

③ Répétez l'étape ② jusqu'à ce que tous les éléments soient triés

Exemple de code:

// 归并排序(递归法)
template<typename T>
void merge_sort_recursive(T arr[], T reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

// merge_sort
template<typename T>
void merge_sort(T arr[], const int len) {
    T reg[15];
    merge_sort_recursive(arr, reg, 0, len - 1);
}

3. Résumé:

Complexité temporelle: le tri par fusion est principalement divisé en divisions et tri de tableaux ordonnés. La complexité temporelle de l'opération de fractionnement est logn et la complexité du tri est n, donc la complexité temporelle du tri par fusion est O (nlogn) tri par fusion La complexité spatiale de est l'espace occupé par le tableau temporaire et les données poussées sur la pile lors de la récursivité: n + logn, donc la complexité spatiale est O (n)

Je suppose que tu aimes

Origine blog.csdn.net/qq_43801020/article/details/108219886
conseillé
Classement