Handleiding voor in-place sorteeralgoritme Werkt met een Java-implementatie

1. Inleiding

In deze zelfstudie leggen we uit hoe het in-place sorteeralgoritme werkt.

2. In-place algoritmen

De in-place algoritmen hebben geen aanvullende gegevensstructuur nodig om de invoergegevens te transformeren. In feite betekent dit dat het algoritme geen extra ruimte gebruikt voor invoermanipulatie. Het overschrijft praktisch de invoer met de uitvoer.

In werkelijkheid kan het algoritme echter een kleine en niet-constante extra ruimte nodig hebben voor hulpvariabelen. De complexiteit van deze ruimte is in de meeste gevallen O (logboek n), hoewel soms alles minder dan lineair is toegestaan.

3. Pseudocode

Laten we nu een pseudocode bekijken en het in-place-algoritme vergelijken met het out-of-place-algoritme.

We gaan ervan uit dat we een reeks van n nummers.

3.1. In-Place-algoritme

Als we nadenken over het probleem, zullen we zien dat we een invoerarray en een omgekeerde array als uitvoer hebben. Uiteindelijk hebben we onze originele array niet echt nodig, alleen de omgekeerde.

Waarom zouden we dan de invoer niet overschrijven in plaats van de waarden naar de volledig nieuwe array te verplaatsen, aangezien dit een meest voor de hand liggende methode lijkt? Om dat te doen, we hebben maar één extra variabele nodig om de waarden waarmee we momenteel werken tijdelijk op te slaan:

reversInPlace (array A [n]) voor i van 0 tot n / 2 temp = A [i] A [i] = A [n - 1 - i] A [n - 1 - i] = temp

Het is opmerkelijk om te vermelden dat, hoe groot de array ook is, de extra ruimte die we nodig hebben altijd zal zijn O (1) in dit geval.

De illustratie laat zien dat we minder stappen nodig hebben dan in het vorige geval:

3.2. Out-of-Place-algoritme

Aan de andere kant kunnen we dit ook op een vrij eenvoudige, meer voor de hand liggende manier doen. We kunnen een nieuwe array van dezelfde grootte maken, de waarden van de originele in de overeenkomstige volgorde kopiëren en vervolgens de originele array verwijderen:

reverseOutOfPlace (array A [n]) maak nieuwe array B [n] voor i van 0 tot n - 1 B [i] = A [i] delete A return B

Hoewel dit zal doen wat we wilden, is het niet efficiënt genoeg. We hebben Aan) extra benodigde ruimteaangezien we twee arrays hebben om mee te manipuleren. Daarnaast is het maken en verwijderen van een nieuwe array meestal een langzame operatie.

Laten we de illustratie van het proces bekijken:

4. Java-implementatie

Laten we nu kijken hoe we in Java kunnen implementeren wat we in de vorige sectie hebben geleerd.

Ten eerste implementeren we een in-place algoritme:

openbare statische int [] reverseInPlace (int A []) {int n = A.length; voor (int i = 0; i <n / 2; i ++) {int temp = A [i]; A [i] = A [n - 1 - i]; A [n - 1 - i] = temp; } retourneer A; }

We kunnen eenvoudig testen of dit werkt zoals verwacht:

@Test openbare leegte gegevenArray_whenInPlaceSort_thenReversed () {int [] input = {1, 2, 3, 4, 5, 6, 7}; int [] verwacht = {7, 6, 5, 4, 3, 2, 1}; assertArrayEquals ("de twee arrays zijn niet gelijk", verwacht, InOutSort.reverseInPlace (invoer)); }

Ten tweede, laten we eens kijken naar de implementatie van het algoritme dat niet op zijn plaats is:

openbare statische int [] reverseOutOfPlace (int A []) {int n = A.length; int [] B = nieuwe int [n]; voor (int i = 0; i <n; i ++) {B [n - i - 1] = A [i]; } terug B; }

De test is vrij eenvoudig:

@Test openbare leegte gegevenArray_whenOutOfPlaceSort_thenReversed () {int [] input = {1, 2, 3, 4, 5, 6, 7}; int [] verwacht = {7, 6, 5, 4, 3, 2, 1}; assertArrayEquals ("de twee arrays zijn niet gelijk", verwacht, InOutSort.reverseOutOfPlace (invoer)); }

5. Voorbeelden

Er zijn veel sorteeralgoritmen die een in-place-benadering gebruiken. Sommigen van hen zijn invoegsortering, bubbelsortering, heapsortering, quicksort en shell-sortering en u kunt er meer over leren en hun Java-implementaties bekijken.

We moeten ook kamsortering en hoopsort vermelden. Al deze hebben een ruimtelijke complexiteit O (logboek n).

Het kan ook nuttig zijn om meer te weten te komen over de Theory of Big-O Notation, en om enkele praktische Java-voorbeelden te bekijken over de complexiteit van het algoritme.

6. Conclusie

In dit artikel hebben we de zogenaamde in-place algoritmen beschreven, geïllustreerd hoe ze werken met pseudocode en een paar voorbeelden, verschillende algoritmen opgesomd die volgens dit principe werken en ten slotte de basisvoorbeelden in Java geïmplementeerd.

Zoals gewoonlijk was de volledige code te vinden op GitHub.