Guten Abend,
erstmal vorweg, ich bin Java-Anfänger, der sich noch mit wahrscheinlich sehr leichten Sachen sehr schwer tut.
Die Aufgabe war, einen QuickSort- Algorithmus für Objekte vom Typ Comparable zu implementieren und diesen an einer vor einigen Wochen erstellten Klasse zu testen(als Interface) ((das ist mein Hauptproblem)).
Mein Lösung bisher:
QuickSort-Algorithmus:
und die zu verknüpfende Klasse:
Ich kriege in der main immer bei:
den Fehler "cannot instantiate the Type Clock" und mir fällt nichts ein, wie ich den beheben soll/kann.
Wie Quick-Sort und der Algorithmus funktioniert ist mir klar, aber die Objektorientierte Programmierung und deren Zusammenhänge bringen mich sehr durcheinander.
Ich hoffe, es findet sich jemand der mir helfen kann bzw mich in die richtige Richtung bringt.
mit freundlichen Grüßen
erstmal vorweg, ich bin Java-Anfänger, der sich noch mit wahrscheinlich sehr leichten Sachen sehr schwer tut.
Die Aufgabe war, einen QuickSort- Algorithmus für Objekte vom Typ Comparable zu implementieren und diesen an einer vor einigen Wochen erstellten Klasse zu testen(als Interface) ((das ist mein Hauptproblem)).
Mein Lösung bisher:
QuickSort-Algorithmus:
Java:
import java.time.Clock;
import java.util.Arrays;
/*********************************************************
hier bitte Antwort zu 1. und 2. als Block-Kommentar einfuegen
**********************************************************/
public class QuickSort {
static int swap;
public static <T extends Comparable<T>> void quickSort(T[] a) {
// TODO: quicksort-algorithm for generics
quickSort(a, 0, a.length-1);
}
private static <T extends Comparable<T>> void quickSort(T[]a, int left, int right) {
if (right > left) {
int pivot = partition(a,left,right);
quickSort(a,left,pivot-1);
quickSort(a,pivot+1,right);
}
}
private static <T extends Comparable <T>> int partition(T[]a, int left,int right) {
T pivot = a[right];
int mid = left;
for(int i=mid; i<right;i++) {
if(a[i].compareTo(pivot)<=0) {
swap(a,i,mid++);
}
}
swap(a,right,mid);
return mid;
}
private static <T extends Comparable <T>> void swap(T[] a,int b,int c) {
if(b!=c) {
T temp = a[b];
a[b] = a[c];
a[c] = temp;
}
}
public static void main(String[] args) {
Clock[] a = new Clock[20];
a[0] = new Clock(0,0);
for(int i=1;i<a.length;i++)
a[i] = new Clock((int)(24*Math.random()),(int)(60*Math.random()));
quickSort(a);
System.out.println(Arrays.toString(a));
}
}
und die zu verknüpfende Klasse:
Code:
public class Clock {
int h; // Stunden (0-23)
int min; // Minuten (0-59)
int gmin; // gesamt-Minuten
// in set-Methoden gmin aktualisieren!!
public Clock() {
h = 0;
min = 0;
gmin = 0;
}
public int getH() {
return h;
}
public int getMin() {
return min;
}
public Clock(int h, int min) {
assert (0 <= h && h <= 23 && 0 <= min && min <= 59) : "unallowable time";
this.h = h;
this.min = min;
gmin = h * 60 + min;
}
public Clock(int min) {
h = (min / 60) % 24;
this.min = min % 60;
gmin = h * 60 + this.min;
}
public Clock(String z) {
String[] el = z.split(":");
h = Integer.parseInt(el[0]);
min = Integer.parseInt(el[1]);
gmin = h * 60 + min;
}
public Clock add(int m) {
int res = gmin + m;
return new Clock(res);
}
public Clock add(Clock t) {
// Weiterverarbeiten des Ergebnisses möglich:
// Clock t = t1.add(t2).add(t3)
int res = gmin + t.gmin;
return new Clock(res);
}
public String toString() {
String erg = "";
erg += h + ":";
if (min < 10)
erg += "0";
erg += min;
return erg;
}
public int compareTo(Clock t) {
if(h>t.h) {
return 1;
}
else if(h<t.h) {
return -1;
}
else {
return min - t.min;
}
}
}
Ich kriege in der main immer bei:
Code:
a[0] = new Clock(0,0);
a[i] = new Clock((int)(24*Math.random()),(int)(60*Math.random()));
Wie Quick-Sort und der Algorithmus funktioniert ist mir klar, aber die Objektorientierte Programmierung und deren Zusammenhänge bringen mich sehr durcheinander.
Ich hoffe, es findet sich jemand der mir helfen kann bzw mich in die richtige Richtung bringt.
mit freundlichen Grüßen