Sortierung in Java zusammenführen, erklärte

Eine Liste oder ein Array, deren Indexierung (Zählung) von Null beginnt. Die Frage ist, wenn die Gesamtzahl der Elemente in der Liste seltsam ist, was ist die linke Hälfte und die rechte Hälfte. Wenn die Gesamtzahl der Elemente gleichmäßig ist, gibt es kein Problem. Wenn die Länge der Liste 8 beträgt, dann hat die linke Hälfte die ersten 4 Elemente, und die rechte Hälfte hat die nächsten 4 Elemente. Wenn die Länge der Liste 5 ist, beispielsweise, was seltsam ist, dann hat die linke Hälfte die ersten drei Elemente und die rechte Hälfte die nächsten 2 Elemente hat.

Wenn die Länge der Liste 8 beträgt, wird der Index für das mittlere (mittlere) Element als 3 angesehen, dh das 4. Element - Indexzählung beginnt von 0 aus 0. Wenn also die Länge der Liste gleich ist, ist der Index für das mittlere Element Länge / 2 - 1.

Wenn die Länge der Liste 5 ist, wird der Index für das mittlere Element als 2 angesehen, was das 3. Element ist. Wenn also die Länge der Liste ungerade ist, ist der Index für das mittlere Element Länge / 2 - 1/2.

Es ist nicht schwierig, die Mitte des Index einer Liste mit Java zu erhalten! - Verwenden Sie einfach die Ganzzahl -Arithmetik. Der Ausdruck für den mittleren Index ist:

Höchstindex / 2

Wenn also die Länge 8 beträgt, wird der höchste Index, der 7 ist, durch 2 geteilt, um 3 und 1/2 zu ergeben. Ganzzahl arithmetische Verwirrung legt die Hälfte ab und lässt Sie 3, dh Länge / 2 - 1.

Wenn die Länge 5 beträgt, wird der höchste Index, der 4 ist, durch 2 geteilt, um 2 zu ergeben, dh Länge / 2 - 1/2.

Zusammenführungsart ist ein Sortieralgorithmus. In diesem Tutorial führt die Sortierung zu einer endgültigen Liste, vom geringsten bis zum höchsten Wert. Zusammenführen Sort. Der Rest dieses Tutorials erklärt, dass es für Java gilt, wie es bei Java gilt.

Artikelinhalt

• Teilen und erobern für die Zusammenführung der Sortierung
• Die Hauptrevursionsmethode
• Die Conquer () -Methode
• Temporäres Array für die Conquer () -Methode
• Abschluss

Teilen und erobern für die Zusammenführung der Sortierung

Teilen Sie die Mittel, um die unsortierte Liste in zwei Hälften zu teilen, wie oben erläutert. Teilen Sie dann jede der Hälften in zwei weitere Hälften. Teilen Sie die resultierenden Hälften weiter, bis es jeweils N -Listen eines Elements gibt, wobei n die Länge der ursprünglichen Liste ist.

Conquer bedeutet bedeutet. Die Paarung wird fortgesetzt, bis eine endgültige sortierte Liste der Längen entspricht, die der ursprünglichen Länge entspricht.

Betrachten Sie die unsortierte Liste der alphabetischen Buchstaben:

M k q c e t g

Die Länge dieser Liste beträgt 7. Das folgende Diagramm zeigt, wie die Zusammenführung dieser Liste theoretisch durchgeführt wird:

Aus dem Diagramm dauert die Aufteilung zu Einzelwerten 3 Schritte. Die Eroberung, die zusammengefügt und sortiert, unternimmt weitere 3 Schritte, um die sortierte endgültige Liste zu haben.

Sollte ein Programmierer 6 Codesegmente schreiben, um dies zu erreichen? - NEIN. Der Programmierer muss über ein Rekursionsschema mit einer temporären Liste verfügen.

Beachten Sie übrigens, dass G in seiner Positionierung für die Teilung der ersten rechten Hälfte ziemlich seltsam aussieht. Dies liegt daran, dass die Länge der Liste eine ungerade Zahl ist, 7. Wenn die Länge eine gleichmäßige Zahl wäre, beispielsweise 6, wäre Q in ähnlicher Weise für die Aufteilung der ersten linken Hälfte als merkwürdig erschienen.

Der Rest dieses Artikels erläutert "Sortier" in Java "unter Verwendung der unortheiligen Liste:

M k q c e t g

Die Hauptrevursionsmethode

In diesem Programm stehen drei Methoden. Die Methoden sind die Divide () -Methode, die Conquer () -Methode und die Main () -Methode. Die Divide () -Methode ist die Hauptmethode. Es ruft sich wiederholt für die linken und rechten Hälften und ruft die Conquer () -Methode am Ende seines Körpers auf. Der Code für die Hauptmethode lautet:

void Divide (char arr [], int bett, int end)
int in Mid;
if (bett < end)
Mid = (Beg + Ende)/2;
teilen (arr, bett, Mid);
divide (arr, Mid+1, Ende);
Eroberung (arr, bett, Mid, Ende);

Zu Beginn nimmt es das angegebene Array, den Beginn (BEG) -Array -Index mit 0 und den Endarray -Index, der 6 beträgt. Die Methode wird nicht ausgeführt, wenn sie nicht mindestens zwei Elemente enthält. Der Scheck erfolgt durch die If-Kondition: „Wenn (bett < 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.

Für die erste Ausführung oder Durchführung der Divide () -Methode ist die IF-Kondition erfüllt (mehr als ein Element). Der mittlere Index beträgt 3 = (0 + 6) / 2 (ganzzahlige Arithmetik). Die drei Methodenaufrufe und ihre Bestellung mit ihren Argumenten werden:

divide (arr, 0, 3);
Divide (arr, 4, 6);
Eroberung (arr, 0, 3, 6);

Hier gibt es drei Anrufe. Die erste dieser Anrufe ruft die Divide () -Methode erneut für die linke Hälfte der Liste auf. Die zweiten beiden Methoden werden in ihrer Bestellung festgestellt und reserviert, um später ausgeführt zu werden. Der zweite Aufruf von Divide () würde die Divide () -Methode für die rechte Hälfte der Liste aufrufen. Die Eroberermethode würde die beiden ersten Hälften zusammen ausführen.

Vor dem zweiten Durchgang der Divide () -Methode sollte die Liste wie folgt in zwei geteilt angesehen werden:

M k q c e t g

Im zweiten Durchgang der Divide () -Methode befasst sich die linke Hälfte der Liste. Der Anruf für den zweiten Pass lautet:

divide (arr, 0, 3);

Diesmal ist der mittlere Index 1 = (0 + 3) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

divide (arr, 0, 1);
divide (arr, 2, 3);
Conquer (arr, 0, 1, 3);

Beachten Sie, dass der neue Endindex 3 ist, was das Ende der ersten linken Hälfte ist. Die erste dieser Anrufe ruft die Divide () -Methode für die linke Hälfte der ersten linken Hälfte der Liste erneut auf. Die zweiten beiden Methoden werden in ihrer Bestellung festgestellt und reserviert, um später mit ihren neuen Argumenten ausgeführt zu werden. Der zweite Aufruf von Divide () würde die Divide () -Methode für die rechte Hälfte der ersten linken Hälfte der Liste aufrufen. Die Conquer () -Methode würde die beiden neuen Hälften ausführen.

Vor dem dritten Durchgang der Divide () -Methode sollte die Liste wie folgt als geteilt angesehen werden:

M k q c e t g

Der dritte Durchgang der Divide -Methode ist der Anruf:

divide (arr, 0, 1);

In diesem dritten Durchgang der Divide () -Methode ist die linke Hälfte der neuen Unterliste der fraglichen Unterliste behandelt. Diesmal ist der mittlere Index 0 = (0 + 1) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

divide (arr, 0, 0);
divide (arr, 1, 1);
Conquer (arr, 0, 0, 1);

Beachten Sie, dass der neue Endindex 1 ist, was das Ende der neuen linken Hälfte ist. Der erste dieser Anrufe ist,

divide (arr, 0, 0);

Es scheitert wegen der If-Kondition: „Wenn (bettieren < end)” - beg, and end are the same, meaning there is only one element. The second divide() method,

divide (arr, 1, 1);

Scheitert auch aus einem ähnlichen Grund. Zu diesem Zeitpunkt sollte die Liste als geteilt angesehen werden als,

M k q c e t g

Der dritte Anruf ist:

Conquer (arr, 0, 0, 1);

Der Eroberer-Aufruf für die beiden Unterlisten ist M und K, das jeweils aus einem Element besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre k m. Die gesamte Liste würde werden:

K m q c e t g

Denken Sie daran, dass es Methoden gibt, die notiert und reserviert wurden. Sie würden jetzt in umgekehrter Reihenfolge mitgerufen werden,

divide (arr, 2, 3);

Dies ist der vierte Durchgang der Divide () -Methode. Es soll die Unterliste Q C verarbeiten, deren Anfangsindex 2 und Endindex 3 beträgt 3. Der mittlere Index ist jetzt 2 = (2 + 3) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

divide (arr, 2, 2);
Divide (arr, 3, 3);
Eroberung (arr, 2, 2, 3);

Der fünfte Durchgang der Divide () -Methode ist der Anruf,

divide (arr, 2, 2);

Beachten Sie, dass der Anfangs- und Endindex gleich ist, was bedeutet, dass es nur ein Element gibt. Dieser Anruf schlägt fehl < end)”. The second divide() call,

Divide (arr, 3, 3);

Scheitert auch aus dem gleichen Grund. Zu diesem Zeitpunkt sollte die Liste als geteilt angesehen werden als,

K m q c e t g

Der dritte Anruf im Methode -Pass lautet:

Eroberung (arr, 2, 2, 3);

Der Eroberer-Aufruf für die beiden Unterlisten ist Q und C, die jeweils aus einem Element besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre C q. Die gesamte Liste würde werden:

K m c q e t g

Denken Sie daran, dass es noch Methoden gibt, die notiert und reserviert wurden. Sie würden weiterhin in umgekehrter Reihenfolge gerufen; jetzt mit,

Divide (arr, 4, 6);

Dies ist der sechste Durchgang der Divide () -Methode. Es soll die Unterliste E t G verarbeiten, deren Anfangsindex 4 und Endindex 6 beträgt. Der mittlere Index ist jetzt 5 = (4 + 6) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

Divide (arr, 4, 5);
Divide (arr, 5, 6);
Eroberung (arr, 4, 5, 6);

Der siebte Durchgang der Divide () -Methode ist der Anruf,

Divide (arr, 4, 5);

Die zweiten zwei Anrufe sind notiert und reserviert. Beachten Sie, dass der neue Endindex 5 ist, was das Ende der neuen linken Hälfte ist. Der mittlere Index ist jetzt 4 = (4 + 5) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

Divide (arr, 4, 4);
divide (arr, 5, 5);
Eroberung (arr, 4, 4, 5);

Der achte Pass ist:

Divide (arr, 4, 4);

Beachten Sie, dass der Anfangs- und Endindex gleich ist, was bedeutet, dass es nur ein Element gibt. Dieser Anruf schlägt fehl < end)”. The second divide() method call is,

divide (arr, 5, 5);

Was auch aus dem gleichen Grund fehlschlägt. Zu diesem Zeitpunkt sollte die Liste als geteilt angesehen werden als,

K m c q e t g

Der dritte Anruf ist:

Eroberung (arr, 4, 4, 5);

Es ist der Eroberer-Aufruf für die beiden Unterlisten: E und T: die erste Unterliste, die aus einem Element besteht, und die zweite Unterliste, die aus einem Element besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre e g . Die gesamte Liste würde werden:

K m q c e t g

Obwohl die E -Sequenz gleich bleibt, beachten Sie, dass die Sortierung stattgefunden hat, obwohl die endgültige Sorte noch kommen soll.

Denken Sie daran, dass es noch Methoden gibt, die notiert und reserviert wurden. Sie werden in umgekehrter Reihenfolge gerufen. Sie werden jetzt beginnt mit dem Beginn mit,

Divide (arr, 5, 6);

Beachten Sie, dass der neue Endindex 6 ist, was das Ende der neuen rechten Hälfte ist. Der mittlere Index ist jetzt 5 = (5 + 6) / 2 (ganzzahlige Arithmetik). Die Methode ruft, ihre Ordnung und Argumente werden,

divide (arr, 5, 5);
divide (arr, 6, 6);
Eroberung (arr, 5, 5, 6);

Die ersten beiden Anrufe fehlen, weil sie sich mit einzelnen Element-Unterlistern befassen. Zu diesem Zeitpunkt lautet die gesamte Liste:

K m q c e t g

Der nächste Anruf ist:

Eroberung (arr, 5, 5, 6);

Es ist der Eroberer-Aufruf für die beiden Unterlisten: T und G: die erste Unterliste, die aus einem Element besteht, und die zweite Unterliste, die aus einem Element besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre g t . Die gesamte Liste würde werden:

K m q c e g t

Denken Sie daran, dass es noch Methoden gibt, die notiert und reserviert wurden. Sie werden in umgekehrter Reihenfolge gerufen. Der nächste, der aufgerufen werden muss, ist,

Conquer (arr, 0, 1, 3);

Es ist der Eroberer-Aufruf für die beiden Unterlisten: K M und Q C: die erste Unterliste, die aus zwei Elementen besteht, und die zweite Unterliste, die aus zwei Elementen besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre c k m q. Die gesamte Liste würde werden:

C k m q e g t

Eine andere Conquer () -Methode, die notiert und reserviert wurde, ist:

Eroberung (arr, 4, 5, 6);

Es ist der Eroberer-Aufruf für die beiden Unterlisten: E G und T. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre e g t. Die gesamte Liste würde werden:

C k m q e g t

Der letzte und zurückhaltende Canquer () -Anruf ist:

Eroberung (arr, 0, 3, 6);

Es ist der Eroberer-Aufruf für die beiden Unterlisten: C k m q und e g t: Die erste Unterliste, die aus vier Elementen besteht, und die zweite Unterliste, die aus drei Elementen besteht. Die Conquer () -Methode verschmilzt und sortiert zwei Unterlisten. Die resultierende Unterliste wäre C e g k m q t, was die gesamte Unterliste ist, dh:

C e g k m q t

Und das endet die Verschmelzung und Sortierung.

Die Conquer () -Methode

Die Eroberungsmethode verschmilzt und sortiert zwei Unterlisten. Eine Unterliste besteht aus mindestens einem Wert. Die Conquer-Methode nimmt das Argument, das ursprüngliche Array, den Anfangsindex der ersten Unterliste, den mittleren Index der beiden zusammen gesehenen Unterlisten und den Endindex der zweiten Unterliste an. Die Eroberungsmethode hat ein temporäres Array, dessen Länge die des ursprünglichen Arrays ist. Der Code für die Conquer -Methode lautet:

void Conquer (char arr [], int Beg, int Mid, int End)
int i = Beg, j = MID+1, K = Beg, index = Beg;
char temp [] = new char [7];
während ich<=mid && j<=end)
if (arr [i]temp [index] = arr [i];
i = i+1;

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

Index ++;

if (i> mid)
während (j<=end)
temp [index] = arr [j];
Index ++;
J ++;


anders
während ich<=mid)
temp [index] = arr [i];
Index ++;
i ++;


k = bett;
während (karr [k] = temp [k];
K ++;

Die Hauptmethode ist:

public static void main (String [] args)
char arr [] = 'm', 'k', 'q', 'c', 'e', ​​'t', 'g';
TheClass mergesort = new theclass ();
Zusammenführen, sortieren.divide (arr, 0,6);
System.aus.println ("Die sortierten Elemente:");
für (int i = 0; i<7;i++)
System.aus.print (arr [i]); System.aus.drucken(");

System.aus.println ();

Die Divide () -Methode, die conquer () -Methode und die main () -Methode sollten zu einer Klasse kombiniert werden. Die Ausgabe ist:

C e g k m q t

Wie erwartet.

Temporäres Array für die Conquer () -Methode

Da die Unterlistenpaare sortiert sind, wird das Ergebnis im temporären Array Temp []. Die Werteanordnung im temporären Array ersetzt letztendlich den Inhalt des ursprünglichen Arrays. Das Folgende zeigt die Anordnung im ursprünglichen Array und das des temporären Arrays für die verschiedenen Anrufe der Conquer () -Methode:

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

Abschluss

Merge -Sort. Es unterteilt eine Liste von Elementen in einzelne Elemente und beginnt dann aufeinanderfolgende Paare von Unterlisten zusammenzubringen, sortiert, beginnend mit den einzelnen Element-Sublisten. Die Kluft und die Eroberung werden zusammen rekursiv durchgeführt. Dieses Tutorial hat erklärt, wie es in Java gemacht wird.

Chrys