RadixSort mit Queues implementieren

[takidoso]

danke, das Rad neu Erfinden, weil es der Prof so will! hab jetzt fast alles, nur noch ein kleiner Fehler:

public class Radix {
	
	public static void main (String[] args) {
		long eingabe[] = new long[args.length];
		
		for(int i=0; i<args.length; i++) {
			try {
				eingabe[i] = Long.parseLong(args[i]);
			} catch (NumberFormatException nfe) {
				System.out.println("Falscher Typ! Nur ganze 4-stellige Zahlen eingeben!");
				}
		}
		
		Queue wart[][] = new Queue[10][4];
		for(int g=0; g<10; g++) {
			for(int i=0; i<4; i++) {
				wart[g][i] = new Queue(args.length);
			}
		}


		for(int j=0; j<eingabe.length; j++) {
			int y = Integer.parseInt((Long.toString(eingabe[j])).substring(3,4));
			wart[y][0].enqueue(eingabe[j]);
		}
		
//		for(int g=0; g<10; g++) {
//		while(wart[g][0].size()>0) {
//			System.out.println(wart[g][0].dequeue());}
//		}
		
		
		for(int h=2; h>=0; h--) {
			for(int d=1; d<4; d++) {
				for(int k=0; k<=9; k++) {
					while (wart[k][d-1].size() > 0) {
						int x = Integer.parseInt((Long.toString(wart[k][d-1].top())).substring(h,h+1));//hier Fehler
						wart[x][d].enqueue(wart[k][d-1].dequeue());
					}
				}
			}
		}
		
		for(int j=0; j<10; j++) {
			while (wart[j][3].size() > 0) {
				System.out.println(wart[j][3].dequeue());
			}
		}
		
//		int hj = Integer.parseInt(((Long.toString(156).substring(0,1))));
//	System.out.println(1052.len);
			
	}
}

in der kommentierten Zeile gibt er mir einen StringIndexOutOfBoundsException-Fehler aus, obwohl ich nur 4-stellige Zahlen eingebe. Müsste meiner Meinung nach Passen, sieht jemand, was ich nicht sehe?

ich habe das mal kurz überflogen und mir fiel in Deiner Annahme der Argumente auf, dass Du einerseits Zahlen jeder Länge parst, aber die Fehlermeldung auf 4 stellige Zahlen plediert. Ich glaube nicht, dass Du das so haben willst, oder?

Funktioniert Dein Programm eigentlich auch, wenn es Zahlen mit weniger als 4 Stellen bekommt?

Ich glaube der Gebrauch von einem zwei dimensionalen Queue-Array is nicht wirklich notwendig, oder? Bisher war ich davon ausgegangen, dass man bei jeder Ziffernuntersuchung immer soviele Queues verwendet, wie eine Ziffer Zeichen enthalten kann (im Dezimalsystem von 0 bis 9, also 10).
Davon benötigt man für den ersten Schritt (für das erstemal einsortieren der Zahlen nach ihren niederwertigsten Ziffern) erstmal nur einen Satz. Für den nächsten Schritt (Einsortieren der der Zahlen gemäß ihrer zweit niedersten Ziffern) wird dieser Q-Satz durchgegangen und seine beinhalteten Zahlen auf einen neuen Q-Satz einsortiert.
Und so weiter man brächte also eigentlich nur 2 Q-Sätze wobei der Ziel-Q-Satz zum neuen Quell wird.

Anstelle also 4 * 10 Queus zu halten und relativ unflexibel zu sein bezogen auf die Länge der eingegebenen Zahlen, könntest Du einfach 2 Q-Arrays mit jeweils 10 Queues verwenden ein Quell-Q-Array und eine Ziel-Q-Array. Nach jedem Mal einsortieren aller gegebenen Zahlen in die "Töpfe" wird das Ziel-Q-Array zum neuen Quell-Q-Array und das alte Quell-Q-Array wird gelöscht (oder wahlweise eine neue Q erzeugt und als Quell-Q verwendet.

Was hieltest Du denn davon?

Ich denke das wäre etwas Resourcenschonender und flexibler in Bezug auf die Anzahl von Ziffern gegebener Zahlen.
Somit wärst Du total unabhängig von der Anzahl der Ziffern!

 

[BassSportler]

Was die Zahlen angeht, laut Aufgabenstellung sollen 4-stellige Zahlen übergeben werden, um auch "1" als "0001" einzunehmen, soll man 4-stellige Zahlen eingeben.

Was den Queue-Array angeht hast du recht, eig. reichen 11 Queues aus, 10 für die Ziffern und eine um weiterzumachen, aber ich fands irgendwie "schön" für jede Ziffer und jede Stelle ne eigene Array zu haben. Natürlich nicht das effektivste, aber ich denk unter diesen Umständen (der Aufgabe) wird man keine Beeinträchtigung wegen Resourcenverbrauch haben.