Shell Sort Implementation in Java: A Step-by-Step Guide

(helle Musik) (auf der Tastatur klicken) Sarah: Okay, also lasst uns die Shell-Sortierung implementieren. Ich habe ein Projekt erstellt. Ich benutze Package Academy. lernprogrammieren. Shellsort. Ich habe das übliche intArray hinzugefügt, den Code zum Ausdrucken des Arrays, und wir brauchen hierfür keine Swap-Methode, da die Einfügesortierung keine Swap-Methode verwendet und dies im Wesentlichen eine Variation der Einfügesortierung ist. So lass uns gehen. Die erste Schleife wird also diejenige sein, die den von uns verwendeten Lückenwert initialisiert und ihn dann bei jeder Iteration reduziert. Wir werden also sagen, dass int gap gleich intArray ist. Länge über zwei. Denn denken Sie daran, wir werden mit intArray beginnen, einer Lücke von intArray. Länge über zwei. Was für dieses Array sieben über zwei sein wird, was drei ist. Und dann werden wir weitermachen, solange die Lücke Null ist. Wenn die Lücke Null ist, bedeutet das, dass wir Elemente mit sich selbst vergleichen. Also brauchen wir eine Lücke von eins. Denken Sie für die endgültige Iteration daran, dass bei der Shell-Sortierung die endgültige Iteration immer eine Lücke von 1 aufweisen muss, da die endgültige Iteration im Wesentlichen eine Einfügesortierung sein soll. Und bei jeder Iteration teilen wir den Lückenwert durch zwei. Bei der ersten Iteration beträgt unser Lückenwert sieben über zwei, also drei. Bei der zweiten Iteration sind es drei über zwei, was eins ist. Die zweite Iteration ist also im Wesentlichen eine Einfügesorte. Jetzt codieren wir das eigentliche Vergleichen und Verschieben. Und wie Sie sehen werden und ich werde Ihnen dies später zeigen, ist das, was wir hier codieren werden, im Wesentlichen die Einfügesorte. Es wird etwas anders aussehen, weil es Lücke verwendet. Aber es handelt sich im Wesentlichen um eine Einfügesorte, und wir werden die beiden Implementierungen, die beiden Codesätze, in einer Minute vergleichen. Also werde ich vier Int sagen, das entspricht einer Lücke. Ich bin weniger als intArray. Länge, weil wir uns alle Elemente im Array ansehen wollen. Ich plus plus. Und wir fangen an, wie wir es mit der Einfügesortierung gemacht haben. Wir werden ein neues Elementfeld mit intArray i zuweisen. Intarray i ist der Wert, den wir betrachten werden. Das ist also im Wesentlichen IntArray Lücke. Und wir werden j verwenden, um das Überqueren zu machen. Also werden wir sagen, während j größer als gleich der Lücke ist, denn wenn j kleiner als die Lücke wird, bedeutet das, dass wir die Vorderseite des Arrays getroffen haben. Und intArray, j minus Lücke ist größer als newElement. Nun, was wollen wir machen? Wir wollen das Element bei intArray um eine Lücke nach oben verschieben. Wir werden also sagen, dass intArray j gleich intArray j minus Lücke ist. Und so, was wir hier sagen, wenn wir das machen, fangen wir mit einer Lücke von drei an, also fangen wir um sieben an, genauso wie wir es mit den Folien gemacht haben. Und in der ersten Iteration vergleichen wir sieben mit j minus Lücke, oder? Weil wir newElement sieben zuweisen werden. J wird um drei anfangen. Und wir werden sagen, ob intArray j minus Lücke, während unsere Lücke für die erste Iteration drei ist. Wenn intArray zero, also 20, größer als sieben ist, wollen wir sieben um drei Positionen nach oben verschieben. Also werden wir intArray j zuweisen, das ist drei. Also IntArray drei mit IntArray drei minus drei, die IntArray null. Also nehmen wir im Wesentlichen die Position Null und ordnen sie Position drei zu. Und dann, wenn wir das getan haben, wollen wir die Lücke von j abziehen, weil wir sagen, dass wir jetzt newElement mit den drei Positionen vergleichen wollen. Nun, wir haben an diesem Punkt die Spitze des Arrays erreicht. Wir werden eine Schleife machen und wir werden sagen, nun, j muss größer oder gleich der Lücke sein und es ist nicht so, weil es zu diesem Zeitpunkt Null ist. Und das liegt daran, dass es hier rechts keine Elemente gibt. Also wollen wir zuerst sieben mit 20 vergleichen. Wenn wir könnten, würden wir dann sieben mit drei Stellen vor 20 vergleichen, aber es gibt nichts. Und so werden wir hier rausfallen. Und was wollen wir an dieser Stelle tun? Genau wie bei der Sortierung der Einfügung, während wir im Grunde sagen, dass wir die Einfügungsstelle für sieben gefunden haben, als wir abbrachen. Und so werden wir intArray j mit newElement zuweisen. Und dies sollte ein wenig vertraut aussehen, da dies im Wesentlichen das ist, was wir mit Einfügesortierung gemacht haben. Nachdem wir das getan haben, kehren wir zu dieser Schleife zurück und ich würde vier. So würde es 55 werden. J würde vier werden und dann würde es einen Vergleich zwischen 55 und 35 geben. Und es wird nichts tun, weil 55 größer als 35 ist. Und an diesem Punkt wird es wieder drei Plätze vorwärts gehen und es gibt nichts, also werden wir nur eine Runde drehen. Ich werde fünf, also vergleicht man eins mit minus 15. Und weil man größer als minus 15 ist, wird man nichts tun, sondern eine Schleife machen. Und noch einmal, es wird sich mit den drei Feldern vergleichen lassen und es gibt nichts, also werden wir zurückkehren. Ich werde sechs, also minus 22. Wir werden minus 22 mit dem vergleichen, was hier ist. Jetzt ist es nicht mehr sieben, es ist 20, weil wir 20 hierher gezogen sind. Minus 22 ist weniger als 20, also werden wir hier 20 verschieben. Und dann vergleichen wir minus 22 mit den drei Feldern, die noch übrig sind. Und dieses Mal haben wir drei Positionen. Wir haben hier tatsächlich sieben, weil wir bei der ersten Iteration sieben nach vorne verschoben haben. Minus 22 ist weniger als sieben, also verschieben wir sieben zurück zu dem Ort, an dem es ursprünglich war, und an diesem Punkt wollen wir drei Felder miteinander vergleichen, und es gibt nichts. Wir haben die Vorderseite des Arrays erreicht und werden hier minus 22 zuweisen. Und an diesem Punkt werden wir eine Schleife machen, ich werde sieben und es wird diese Bedingung nicht erfüllen. Und so werden wir aussteigen, wieder in die Lückenschleife zurückkehren. Reduzieren Sie die Lücke auf eins und an diesem Punkt, wenn wir diesen Code eingeben, führen wir im Wesentlichen eine Einfügesortierung durch. Und so optimiert die Shell-Sortierung die Einfügesortierung. Lassen Sie uns dies ausführen, um sicherzustellen, dass es funktioniert. Und wir bekommen die üblichen Minus 22, Minus 15, Eins, Sieben, 20, 35 und 55. Lassen Sie uns für eine Minute ein paar Folien durchgehen, um den Code für die Einfügesortierung mit dem Code für die Shellsortierung zu vergleichen. Okay, hier ist der Code, den wir für die Einfügesortierung geschrieben haben. Und wir können sehen, dass wir hier mit einem ersten unsortierten Index als einem beginnen. Wir weisen newElement mit dem Wert zu, der diesem Wert entspricht. Wir haben i und dann durchlaufen wir natürlich alle Elemente bis zum Ende des Arrays und verschieben, wenn möglich, Elemente nach rechts. Und wenn wir diese Schleife verlassen, haben wir die Einfügeposition für newElements gefunden. Also weisen wir newElement i zu. Hier ist die Art der Muschel. Und wenn Sie diesen Teil für eine Minute ignorieren, werden Sie feststellen, dass dieser Code ziemlich gleich ist. Der einzige Unterschied besteht darin, dass wir anstelle von eins den Lückenwert verwenden. Also werden wir in der ersten Iteration drei verwenden. Und noch einmal, wenn wir zur Einfügesortierung zurückkehren, weisen wir newElement den ersten unsortierten intArray-Index zu. Während der Shell-Sortierung weisen wir newElement das zu, was auch immer an i, dem Lückenwert, liegt. Wir weisen j i zu. Es ist ziemlich ähnlich zu dem, was wir hier machen, außer dass die Schleife sich um die Zuweisung von i kümmert. Hier brauchen wir einen anderen Index, weil wir i nicht ändern wollen, während wir die Partition durchlaufen, nicht die sortierte Partition, sondern den Teil des Arrays, den wir in Einfügeposition vier suchen. Und dann sagen wir in Shell-Sortierung, während j groß oder gleich Lücke ist und intArray j minus Lücke größer als newElement ist, solange das wahr ist, werden wir die Elemente verschieben, mit denen wir vergleichen. Wir werden das Array um Lückenpositionen nach oben verschieben und dann müssen wir die Position des nächsten Elements, das wir durch die Lücke betrachten, verringern, weil wir immer das Element betrachten möchten, das Lückenpositionen entfernt ist. Und das ist sehr ähnlich zu dem, was wir hier machen. Wir sagen dasselbe, solange wir nicht an der Front angekommen sind. Und das heißt, solange wir die Front nicht getroffen haben und das Element, das wir in der Shell-Sortierung betrachten, nicht wirklich die sortierte Partition ist, sondern das Element, das wir betrachten, das die Lückenpositionen sind entfernt, ist größer als newElement. Und zurück in der Einfügesorte, solange das Element, das wir betrachten, größer als newElement ist, wollen wir die Verschiebung durchführen. Und hier wollen wir die Verlagerung machen. Und da wir hier eine Lücke verwenden, müssen wir den nächsten Index berechnen, den wir anders betrachten möchten. Wir können es nicht einfach um eins dekrementieren, da wir hier eine Lücke von eins annehmen. Und wenn wir diese Schleife verlassen, weisen wir intArray i newElement zu. Und hier weisen wir, wenn wir die Schleife verlassen, intArray j newElement zu. Wenn Sie sich also diese beiden Codesätze ansehen, sehen Sie, dass hier wieder die Sortierung der Einfügung und hier die Sortierung der Shell erfolgt. Wir untersuchen nur Elemente, die weiter entfernt sind, mit Ausnahme der letzten Iteration. Bei der letzten Iteration, wenn die Lücke eins ist, ist das, was wir hier tun, genau dasselbe wie das, was wir hier tun. Und so machen wir die letzte Iteration, wenn die Lücke eins ist, im Wesentlichen in der Einfügesorte. Und genau das macht die Shell-Sortierung, aber natürlich haben wir bei der Shell-Sortierung in der letzten Iteration einige der Elemente bereits näher an ihre sortierten Positionen gebracht, so dass es viel weniger Verschiebungen geben wird, die stattfinden müssen. Und so verbessert sich die Shell-Sortierung gegenüber dem Einfügesortierungsalgorithmus. Und wie bereits erwähnt, können Sie mit derselben Idee auch die Blasensortierung verbessern. Sie machen einige Vorarbeiten. Anstatt also Nachbarn zu untersuchen und auszutauschen, untersuchen Sie weiter entfernte Elemente und tauschen sie bei Bedarf aus. Und so, bis Sie zu der Blasenart kommen, bei der Sie eine Lücke von eins verwenden, werden Sie viel weniger tauschen müssen. Das ist also eine Art Muschel. Das ist es, was der Shell-Sortieralgorithmus für die Einfügesortierung und auch für die Blasensortierung macht. Wir sehen uns im nächsten Video.