Was macht dieser Java-Post-Inkrement-Operator?

Question

So ist es ein Stück eines Radixsort Java-Code implementiert, wie unten lautet:

aux[count[a[i]]++] = a[i]; 

Warum einen Beitrag Inkrementoperator verwenden? Warum nicht aux [Anzahl [a [i]] + 1]? Ist das Post-Inkrement einfach, um den Wert in count [a [i]] um 1 zu erhöhen und dort zu speichern?

radixSort.java

int N = a.length; 
int[] count = new int[R+1]; 
for (int i = 0; i < N; i++) 
    count[a[i]+1]++; 
for (int r = 0; r < R; r++) 
    count[r+1] += count[r]; 

for (int i = 0; i < N; i++) 
    aux[count[a[i]]++] = a[i]; 
for (int i = 0; i < N; i++) 
    a[i] = aux[i]; 

Answer 1

Ist der Beitrag Schritt einfach den Wert in Zahl zu erhöhen [a [i]] um 1 und dort speichern?

Ja, genau. Es gibt zwei Nebenwirkungen der Anweisung: eine ist eine Änderung an einem Element von aux, und die andere ist eine Änderung an einem Element in count.

Persönlich würde ich vermeiden, es so zu schreiben - ich würde wahrscheinlich schreiben:

// We don't use i other than to index into a, so use an 
// enhanced for loop instead 
for (int value : a) 
{ 
    aux[count[value]] = value; 
    count[value]++; 
} 

Beachten Sie, dass selbst wenn die Änderung count nicht erforderlich waren, aux[count[a[i]]+1] würde die gleiche Sache nicht tun - weil aux[count[a[i]]++] bezieht sich auf das Element in aux mit Index count[a[i]], vor das Inkrement, weil hier ++ als Post-Inkrement verwendet wird.

Answer 2

Diese aux[count[a[i]]++] = a[i]; bedeutet:

erste, a[i] Wert annehmen, und als Index für Zählung verwenden. Dann verwende diesen Wert als Index in aux Array und setze den Wert von a[i] an seinen Platz. Erhöhen Sie dann den Wert an Position count[a[i]] für 1.

Sein wie folgt aus:

aux[count[a[i]]] = a[i]; 
count[a[i]] = count[a[i]] + 1; 

aber kürzer.

Sie haben auch folgendes: aux[++count[a[i]]] = a[i];. Dies dauert Wert von count[a[i]] und ersten Zuwachs für 1 und es dann als Index in aux Array verwenden, so jetzt haben wir es zu suchen, wie:

count[a[i]] = count[a[i]] + 1; 
aux[count[a[i]]] = a[i]; 

Wie Sie sehen können, ist aux[count[a[i]]+1] nicht aux[count[a[i]]++] mögen, da wird es Speichern Sie keinen erhöhten Wert von a[i] für 1 in a[i], und es wird den Index a[i] + 1 von aux übernehmen, aber aux[count[a[i]]++] braucht Index von a[i].

aux[count[a[i]]+1] ist ähnlich wie aux[++count[a[i]]], aber der Unterschied ist, dass Sie den Wert in count[a[i]] nicht erhöht haben.