Fusion Toi dans Java expliqué

Une liste ou un tableau dont l'indexation (comptage) commence à partir de zéro peut être divisée par deux. La question est que lorsque le nombre total d'éléments dans la liste est étrange, quelle est la moitié gauche et quelle est la moitié droite. Lorsque le nombre total d'éléments est égal, il n'y a pas de problème. Si la longueur de la liste est de 8, disons, alors la moitié gauche a les 4 premiers éléments, et la moitié droite a les 4 prochains éléments. Si la longueur de la liste est de 5, disons, ce qui est étrange, alors par convention, la moitié gauche a les 3 premiers éléments, et la moitié droite a les 2 prochains éléments.

Si la longueur de la liste est de 8, alors l'index pour l'élément (milieu) moyen est considéré comme 3, ce qui est, le 4ème élément - le comptage d'index commence à partir de 0. Ainsi, lorsque la longueur de la liste est uniforme, l'index pour l'élément moyen est la longueur / 2 - 1.

Si la longueur de la liste est de 5, alors l'index pour l'élément moyen est considéré comme 2, qui est le 3ème élément. Ainsi, lorsque la longueur de la liste est impair, l'index pour l'élément moyen est la longueur / 2 - 1/2.

Il n'est pas difficile d'obtenir l'index moyen d'une liste avec Java! - Utilisez simplement l'arithmétique entier. L'expression de l'indice médian est:

HighestIndex / 2

Ainsi, si la longueur est de 8, l'indice le plus élevé, qui est de 7, est divisé par 2 pour donner 3 et un 1/2. L'arithmétique entier rejette la moitié, vous laissant avec 3, ce qui est, longueur / 2 - 1.

Si la longueur est de 5, l'indice le plus élevé, qui est de 4, est divisé par 2 pour donner 2, ce qui est la longueur / 2 - 1/2.

Merge Sort est un algorithme de tri. Dans ce tutoriel, le tri se traduira par une liste finale, du moins à la valeur la plus élevée. Fusiter Sort utilise le paradigme de division et de conquête. Le reste de ce tutoriel explique que, comme il s'applique à Java.

Contenu de l'article

• Diviser et conquérir pour la fusion
• La principale méthode de récursivité
• La méthode Conquer ()
• Tableau temporaire pour la méthode Conquer ()
• Conclusion

Diviser et conquérir pour la fusion

Diviser les moyens de diviser la liste non triée en deux moitiés, comme expliqué ci-dessus. Puis divisez chacune des moitiés en deux autres moitiés. Continuez à diviser les moitiés résultantes jusqu'à ce qu'il y ait n listes d'un élément chacune, où n est la longueur de la liste originale.

Conquérir signifie commencer à jumeler les listes consécutives en une seule liste tout en triant la liste résultante. L'appariement se poursuit jusqu'à ce qu'une liste triée finale de longueurs soit égale à la longueur d'origine est obtenue.

Considérez la liste non triée des lettres alphabétiques:

M k q c e t g

La durée de cette liste est 7. Le diagramme suivant illustre comment la fusion de cette liste se fait en théorie:

Du diagramme, la division à des valeurs uniques prend 3 étapes. La conquér, qui fusionne et le tri, prend encore 3 étapes pour avoir la liste finale triée.

Devrait un programmeur d'écriture de 6 segments de code pour y parvenir? - Non. Le programmeur doit avoir un schéma de récursivité en utilisant une liste temporaire.

Soit dit en passant, remarquez que G semble plutôt étrange dans son positionnement pour la division de la première moitié droite. En effet, la longueur de la liste est un nombre impair, 7. Si la longueur était un nombre uniforme, disons 6, Q serait apparu comme étrange d'une manière similaire à la division de la première moitié gauche.

Le reste de cet article explique «Merge Sort in Java», en utilisant la liste non triée:

M k q c e t g

La principale méthode de récursivité

Il existe trois méthodes dans ce programme. Les méthodes sont la méthode Divide (), la méthode Conquer () et la méthode principale (). La méthode divide () est la méthode principale. Il s'appelle à plusieurs reprises pour les moitiés gauche et droite et appelle la méthode Conquer () à la fin de son corps. Le code de la méthode principale est:

vide divide (char arr [], int Beg, int fin)
int mid;
Si (mendier < end)
mid = (Beg + end) / 2;
diviser (arr, Beg, mid);
diviser (arr, mid + 1, end);
conquérir (arr, Beg, mid, end);

Au début, il faut le tableau donné, l'indice de tableau début (BEG), qui est de 0, et l'indice du tableau de fin, qui est 6. La méthode ne s'exécutera pas si elle n'a pas au moins deux éléments. Le chèque est effectué par la condition IF, «If (Beg < end)”. The first divide() recall calls the left half of the list, and the second divide() recall calls the right to half of the list.

Ainsi, pour la première exécution ou pass. L'indice moyen est 3 = (0 + 6) / 2 (Arithmétique entier). Les trois appels de méthode et leur ordre avec leurs arguments deviennent:

diviser (arr, 0, 3);
Diviser (Arr, 4, 6);
conquérir (arr, 0, 3, 6);

Il y a trois appels ici. Le premier de ces appels, appelle à nouveau la méthode Divide () pour la moitié gauche de la liste. Les deux secondes de méthodes sont notées et réservées dans leur ordre, à exécuter plus tard. Le deuxième appel Divide () appellerait la méthode Divide () pour la moitié droite de la liste. La méthode Conquer exécuterait les deux premières moitiés ensemble.

Avant la deuxième passe de la méthode Divide (), la liste doit être considérée comme divisée en deux comme suit:

M k q c e t g

Dans la deuxième passe de la méthode Divide (), la moitié gauche de la liste est prise en compte. L'appel pour la deuxième passe est:

diviser (arr, 0, 3);

Cette fois, l'index moyen est, 1 = (0 + 3) / 2 (arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

diviser (arr, 0, 1);
Diviser (Arr, 2, 3);
conquérir (arr, 0, 1, 3);

Notez que le nouvel indice final est de 3, ce qui est la fin de la première moitié gauche. Le premier de ces appels, appelle à nouveau la méthode Divide () pour la moitié gauche de la première moitié gauche de la liste. Les deux secondes de méthodes sont notées et réservées dans leur ordre, à exécuter plus tard, avec leurs nouveaux arguments. Le deuxième appel Divide () appellerait la méthode Divide () pour la moitié droite de la première moitié gauche de la liste. La méthode Conquer () exécuterait les deux nouvelles moitiés.

Avant la troisième passe de la méthode Divide (), la liste doit être considérée comme divisée comme suit:

M k q c e t g

La troisième passe de la méthode de division est l'appel:

diviser (arr, 0, 1);

Dans cette troisième passe de la méthode Divide (), la moitié gauche de la nouvelle sous-liste en question est prise. Cette fois, l'index moyen est, 0 = (0 + 1) / 2 (Arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

diviser (arr, 0, 0);
Diviser (Arr, 1, 1);
conquérir (arr, 0, 0, 1);

Notez que le nouvel indice final est 1, qui est la fin de la nouvelle moitié gauche. Le premier de ces appels est,

diviser (arr, 0, 0);

Il échoue à cause de la condition de la condition: «Si (demande < end)” - beg, and end are the same, meaning there is only one element. The second divide() method,

Diviser (Arr, 1, 1);

Échoue également pour une raison similaire. À ce stade, la liste doit être considérée comme divisée comme,

M k q c e t g

Le troisième appel est:

conquérir (arr, 0, 0, 1);

L'appel conquérant pour les deux sous-listes est M et K, chacun composé d'un élément. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait k m. La liste entière deviendrait:

K m q c e t g

N'oubliez pas qu'il existe des méthodes, qui ont été notées et réservées. Ils seraient appelés dans l'ordre inverse, maintenant avec,

Diviser (Arr, 2, 3);

Ceci est la quatrième passe de la méthode Divide (). C'est pour gérer la sous-liste, Q C, dont l'indice de début est 2 et l'index de fin est 3. L'indice moyen est maintenant 2 = (2 + 3) / 2 (arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

Diviser (Arr, 2, 2);
Diviser (Arr, 3, 3);
conquérir (arr, 2, 2, 3);

La cinquième passe de la méthode Divide () est l'appel,

Diviser (Arr, 2, 2);

Notez que l'indice de début et de fin est le même, ce qui signifie qu'il n'y a qu'un seul élément. Cet appel échoue, à cause de la condition de la condition, «si (demande < end)”. The second divide() call,

Diviser (Arr, 3, 3);

Échoue également pour la même raison. À ce stade, la liste doit être considérée comme divisée comme,

K m q c e t g

Le troisième appel dans le pass de méthode est:

conquérir (arr, 2, 2, 3);

L'appel conquérant pour les deux sous-listes est Q et C, chacun composé d'un élément. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait c q. La liste entière deviendrait:

K m c q e t g

N'oubliez pas qu'il existe encore des méthodes, qui ont été notées et réservées. Ils continueraient d'être appelés dans l'ordre inverse; maintenant avec,

Diviser (Arr, 4, 6);

Ceci est la sixième passe de la méthode Divide (). Il s'agit de gérer la sous-liste, E T G, dont l'indice débutant est 4 et l'indice de fin est 6. L'indice médian est maintenant 5 = (4 + 6) / 2 (Arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

Diviser (Arr, 4, 5);
Diviser (Arr, 5, 6);
conquérir (arr, 4, 5, 6);

La septième passe de la méthode Divide () est l'appel,

Diviser (Arr, 4, 5);

Les deux seconds appels sont notés et réservés. Notez que le nouvel indice final est de 5, ce qui est la fin de la nouvelle moitié gauche. L'indice moyen est maintenant 4 = (4 + 5) / 2 (Arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

Diviser (Arr, 4, 4);
Diviser (Arr, 5, 5);
conquérir (arr, 4, 4, 5);

La huitième col est:

Diviser (Arr, 4, 4);

Notez que l'indice de début et de fin est le même, ce qui signifie qu'il n'y a qu'un seul élément. Cet appel échoue, à cause de la condition de la condition, «si (demande < end)”. The second divide() method call is,

Diviser (Arr, 5, 5);

Qui échoue également pour la même raison. À ce stade, la liste doit être considérée comme divisée comme,

K m c q e t g

Le troisième appel est:

conquérir (arr, 4, 4, 5);

C'est l'appel conquérant pour les deux sous-listes: E et T: la première sous-liste composée d'un élément, et la deuxième sous-liste composée d'un élément. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait e g . La liste entière deviendrait:

K m q c e t g

Bien que la séquence E T reste la même, notez que le tri a eu lieu, bien que le tri final soit encore à venir.

N'oubliez pas qu'il existe encore des méthodes qui ont été notées et réservées. Ils sont appelés dans l'ordre inverse. Ils seront maintenant appelés en commençant par,

Diviser (Arr, 5, 6);

Notez que le nouvel indice final est de 6, ce qui est la fin de la nouvelle moitié droite. L'indice médian est maintenant 5 = (5 + 6) / 2 (arithmétique entier). Les appels de la méthode, leur ordre et leurs arguments deviennent,

Diviser (Arr, 5, 5);
Diviser (Arr, 6, 6);
conquérir (arr, 5, 5, 6);

Les deux premiers appels échouent car ils s'adressent aux sous-listes à élément unique. À ce stade, toute la liste est:

K m q c e t g

L'appel suivant est:

conquérir (arr, 5, 5, 6);

C'est l'appel conquérant pour les deux sous-listes: T et G: la première sous-liste composée d'un élément, et la deuxième sous-liste composée d'un élément. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait g t . La liste entière deviendrait:

K m q c e g t

N'oubliez pas qu'il existe encore des méthodes qui ont été notées et réservées. Ils sont appelés dans l'ordre inverse. Le suivant à appeler est,

conquérir (arr, 0, 1, 3);

C'est l'appel conquérant pour les deux sous-listes: K M et Q C: la première sous-liste composée de deux éléments, et la deuxième sous-liste composée de deux éléments. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait c k m q. La liste entière deviendrait:

C k m q e g t

Une autre méthode Conquer () qui a été notée et réservée est:

conquérir (arr, 4, 5, 6);

C'est l'appel conquérant pour les deux sous-listes: e g et t. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait e g t. La liste entière deviendrait:

C k m q e g t

Le dernier appel conquérant () noté et réservé est:

conquérir (arr, 0, 3, 6);

C'est l'appel conquérant pour les deux sous-listes: C K M Q et E G T: la première sous-liste composée de quatre éléments, et la deuxième sous-liste composée de trois éléments. La méthode Conquer () fusionne et trie deux sous-listes. La sous-liste résultante serait c e g k m q t, qui est la sous-liste complète, c'est-à-dire:

C e g k m q t

Et cela met fin à la fusion et au tri.

La méthode Conquer ()

La méthode Conquier fusionne et trie deux sous-listes. Une sous-liste se compose d'au moins une valeur. La méthode de conquér prend comme argument, le tableau d'origine, l'indice de début de la première sous-liste, l'indice médian des deux sous-listes consécutifs vus ensemble et l'indice final du deuxième sous-liste. La méthode Conquer a un tableau temporaire, dont la longueur est celle du tableau d'origine. Le code de la méthode Conquer est:

void conquér (char arr [], int Beg, int mid, int fin)
int i = Beg, j = mid + 1, k = Beg, index = Beg;
char à char [] = nouveau char [7];
alors que je<=mid && j<=end)
if (arr [i]temp [index] = arr [i];
i = i + 1;

autre
temp [index] = arr [j];
J = J + 1;

index ++;

if (i> mid)
tandis que (J<=end)
temp [index] = arr [j];
index ++;
j ++;


autre
alors que je<=mid)
temp [index] = arr [i];
index ++;
i ++;


K = Beg;
Pendant que (karr [k] = temp [k];
k ++;

La méthode principale est:

public static void main (String [] args)
char arr [] = 'm', 'k', 'q', 'c', 'e', ​​'t', 'g';
Theclass Mergesort = new theclass ();
tri par fusion.Diviser (arr, 0,6);
Système.dehors.println ("Les éléments triés:");
pour (int i = 0; i<7;i++)
Système.dehors.print (arr [i]); Système.dehors.imprimer(");

Système.dehors.println ();

La méthode divide (), la méthode Conquer () et la méthode principale () doivent être combinées en une seule classe. La sortie est:

C e g k m q t

Comme prévu.

Tableau temporaire pour la méthode Conquer ()

Au fur et à mesure que les paires de sous-liste sont triées, le résultat est maintenu dans le tableau temporaire, température []. La disposition des valeurs dans le tableau temporaire remplace finalement le contenu du tableau d'origine. Ce qui suit montre l'arrangement dans le tableau d'origine et celui du tableau temporaire pour les différents appels de la méthode Conquer ():

conquérir (arr, 0, 0, 1);
arr [7]: m k q c e t g
Temp [7]: k m - - - - -
conquérir (arr, 2, 2, 3);
arr [7]: k m q c e t g
Temp [7]: k m c q - - -
conquérir (arr, 4, 4, 5);
arr [7]: k m c q e t g
Temp [7]: k m c q e t -
conquérir (arr, 5, 5, 6);
arr [7]: k m c q e t g
Temp [7]: k m c q e g t
conquérir (arr, 0, 1, 3);
arr [7]: k m c q e g t
temp [7]: c k m q e g t
conquérir (arr, 4, 5, 6);
arr [7]: c k m q e g t
temp [7]: c k m q e g t
conquérir (arr, 0, 3, 6);
arr [7]: c k m q e g t
temp [7]: c e g k m q t

Conclusion

Merge Syt est un schéma de tri qui utilise le paradigme de division et de conquête. Il divise une liste d'éléments en éléments uniques, puis commence à réunir des paires de sous-listes consécutives, triées, à partir des sous-listes d'élément unique. Les procédures de division et de conquête sont ensemble réalisées. Ce tutoriel a expliqué comment il se fait en Java.

Chrys