Shellsort

[rübe]

Hey ich bin Java Anfänger und hätte da mal eine Frage, ich komme überhaupt nicht weiter.

Die Aufgabe ist:
Implementieren Sie eine Klasse Sort, die die Klassenmethode Shellsort zur Verfügung stellt, die jeweils ein Objekt vom Typ SimpleCollection übergeben bekommt und sortiert.

Geben ist die class Sort (so wie sie in den Programm ist),geben ist die Methode shell_sort (so wie sie in den Programm ist)und geben ist das Interface SimpleCollection (so wie sie in den Programm ist).

Wenn ich richtig annehme sind die Methoden size, get, push_front und push_back. Nur wichtig wenn ich das später in die doppelt verkettete Liste (was die nächste Aufgabe ist) integriere. Deswegen sind sie nur so halb fertig programmiert, so das das Programm kein Fehler werfen kann (wegen des Interface).

In der main methode erzeuge ich 10 zufällige Zahlen die dann durch den shell sort sortiert werden.

Mein Problem ist ich weiß nicht genau was <T extends Comparable<T> zu bedeuten hat. Nur das Comparable ein vordefinierte klasse von java ist die irgendwas mit sortieren zu tun hat.

Und ich weiß nicht wie man int wert zu ein Objekt macht so das die Shellsort Klasse die Zahlen verwenden kann.

Ich weiß überhaupt nicht was ich mit der Sort Klasse machen soll.

interface SimpleCollection<T>{
	public int size();
	public void push_fornt(T obj);
	public void push_back(T obj);
	public T get(int i);
}

class Shellsort implements SimpleCollection{							// das ist geben
	static <K extends Comparable<K>> void shell_sort(K[] field) {
		int iDist = 1;
		for( ; iDist <= field.length / 9; iDist = 3 * iDist + 1) {
		}
		for( ; iDist > 0; iDist /= 3) {
			for(int i1 = iDist; i1 < field.length; ++i1) {
				final K IVAL = field[i1];
				int i2 = i1;
				while (i2 >= iDist && field[i2 - iDist].compareTo(IVAL) > 0) {
					field[i2] = field[i2 - iDist];
					i2 = i2 - iDist;
				}
				field[i2] = IVAL;
			}
		}
	}

	public int size() {
		return 0;
	}

	public Object get(int i) {
		return null;
	}


	public void push_fornt(Object obj) {
	
	}

	public void push_back(Object obj) {
		
	}
}	
class Sort{											// das ist geben
	public static <T extends Comparable<T>>
		void Shellsort(SimpleCollection<T> col);

}

public class Shellsort1{
	public static void print(int[] zahl){			// gibt zahlen aus
		for(int i = 0;i < zahl.length;++i){
			System.out.print(zahl[i] + " ");
		}
	}
	public static void main(String[]args){
		int[] zahl = new int[10];
		for(int i = 0; i < zahl.length;++i){
			zahl[i] = (int)(Math.random() * 100);
		}
		print(zahl);
		Shellsort.shell_sort(zahl);				// einer meiner versuche die shell sort kalss aufzurufen
		System.out.println(" ");
		print(zahl);
	}
}

 

[kaoZ]

<T extends Comparable<T>

bedeutet das T entweder Comparable<T> erweitert oder das Interface implementiert

sowas wird zum Beispiel auch genutzt wenn man Flexiblen Code Schreiben möchte und nicht weiß welche Klassen vielleicht später noch dazu kommen, oder welchen SubTyp du vielleicht später benötigst.

z.B

ArrayList<? extends Foo> list = new ArrayList<>();

Hierbei wird ? als WildCard für eine noch unbekannte Klasse die Foo erweitert eingesetzt, wäre Foo ein Interface würde es Bedeuten du könntest jede Klasse übergeben die das Interface implementiert.

extends steht in diesem zusammenhang für erweitert oder implementiert

im gegensatz dazu existiert noch die Syntax :

ArrayList<? super Foo> list = new ArrayList<>();

diese bedeutet das eine noch unbekannte Klasse , die Superklasse von Foo ist , ( oder Foo selbst die Superklasse ist ) Heißt konkret du kannst in die List Objekte vom Typ Foo einfügen , oder insofern Foo eine Subklasse ist, auch Objekte der Superklasse von Foo.

Bedenke dabei das dies nur bei Generischen Typen funktioniert !