Methodenkopf

Bitte aktiviere JavaScript!
A

Anzeige




Schau mal hier —> (hier klicken)
Das passt so.

Welchen Fehler genau zeigt Eclipse denn an?

Wenn Eclipse nicht will, nimm einfach direkt java (und wenn nötig javac)
 
Du hast nicht zufällig noch irgendeinen anderen Import da rumschwirren oder irgendwas im gleichen Package liegen?


Versuchs einfach mal direkt mit java, ohne Eclipse.
 
Ja das war das Problem. Vielen Dank.
Ich habe die Methode getestet, wie folgt:
Java:
List<Integer> a=new LinkedList<Integer>();
    a.add(3);
    a.add(1);
    a.add(5);
    System.out.println(a);
    sort(a);
    System.out.println(a);
Es wird leider nichts sortiert. Wo liegt denn der Fehler?
 
Wie kann ich das lösen?
Du musst für den Sotieralgorithmus auch eine implementierung angeben... (Das ist doch Sinn der Sache...)

Mal was verrücktes aus der Versuchskiste: :D

Java:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ShuffleSort {
    public static void main(String[] args) {
        System.out.println(sort(new ArrayList(List.of(C.c("c"), C.c("a"), C.c("b"), C.c("d")))));
    }

    public static <T extends Comparable<? super T>> List<T> sort(List<T> list) {
        while (!issorted(list)) {
            Collections.shuffle(list);
        }
        return list;
    }

    private static <T extends Comparable<? super T>> boolean issorted(List<T> list) {
        final int N = list.size() - 1;
        for (int i = 0; i < N; i++) {
            if (!(list.get(i).compareTo(list.get(i + 1)) < 0)) {
                return false;
            }
        }
        return true;
    }
}

interface A extends CharSequence, Comparable<CharSequence> { }

abstract class B implements A { }

class C extends B {
    String a;

    public static C c(String a) {
        return new C(a);
    }

    public C(String a) {
        this.a = a;
    }

    @Override
    public int compareTo(CharSequence arg0) {
        return a.compareTo(arg0.toString());
    }

    @Override
    public String toString() {
        return a;
    }

    @Override
    public int length() {
        return a.length();
    }

    @Override
    public char charAt(int arg0) {
        return a.charAt(arg0);
    }

    @Override
    public CharSequence subSequence(int arg0, int arg1) {
        return a.substring(arg0, arg1);
    }
}
Für bereits sortierte Listen ist die Laufzeit super. :D In issorted könnte man bei Verknüpfungen noch einen Iterator hernehmen... hth
 
Java:
public static <T extends Comparable<? super T>> void sort(List<T> list) {
     
       for(int j = 1 ; j < list.size(); j++){
           T elem=list.get(j);
           int i=j-1;
           while(i>0 && (elem.compareTo(list.get(i))<0)){
               list.set(i+1,list.get(i));  
               i--;
           }
           list.set(i+1,elem);
     
       }
Geht doch deine Code mal gedanklich durch oder verwende einen Debugger und schau dir Schritt für Schritt an, was passiert.

Bei j=1 wird i=0 und damit die while-Schleife überhaupt nicht bearbeitet.
Bei j=2 wird i=1, elem="Element2". In der while-Schleife wird abhängig vom Vergleich das 2. Element auf den Inhalt des 1. Elements gesetzt und nach der while-Schleife wird genau dieses Element wieder auf den Inhalt des ursprünglich 2. Elements gesetzt.
 
Ok dann ist also nicht mein Beispieltestprogramm falsch, sondern die Methode sort() selbst.
Ich habe mich bei der Implementierung an dem Pseudocode für InsertionSort orientiert.
Ich bin es nochmal durchgegangen.
Ich kann den Fehler einfach nicht finden?
 
Ich kann den Fehler einfach nicht finden?
hallo nochmal,
InsertionSort?, der Pseudocode auf Wikipedia (deutsch) ist ja schrecklich, da finde ich SelectionSort angenehmer... das ist aber auch nicht so wichtig. Ich habe das jetzt einmal gemacht, aber die anderen musst Du alle machen. So KANN eine implementierung schauen:
Java:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class InsertionSort {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(List.of(
                "b",
                new String("c")/*pooling :(*/,
                new String("c"),
                "a")/*immutable*/)/*de-immutable*/;
        Collections.shuffle(list);/*demonstrate*/
        System.out.println(list);
        for (String s : list) {
            System.out.println(System.identityHashCode(s/*statically-typed :(*/));
        }
        System.out.println(sort(list));
        for (String s : list) {
            System.out.println(System.identityHashCode(s));
        }
    }

    public static <T extends Comparable<? super T>> List<T> sort(List<T> list) {
        Comparable[] a = new Comparable[list.size()];/*generic array creation :(*/
        for (int i = 0; i < list.size(); i++) {
            a[i] = list.get(i);
        }

        for (int i = 1; i < a.length; i++) {
            Comparable c = a[i];
            int j = i;
            for (; j > 0 && c.compareTo(a[j - 1]) < /*stable/stabil*/ 0; j--) {
                a[j] = a[j - 1];
            }
            a[j] = c;
        }

        list.clear();
        for (Comparable c : a) {
            list.add((T)/*safe*/ c);
        }

        return list;
    }
}

Bis dann.
 
Hallo,
Danke für deine Antwort. Ich verstehe deinen Code auch.
Aber warum geht den mein Programm nicht.
Ich würde gerne den Fehler beheben, auch wenn der Pseudocode als Vorlage nicht der beste ist :)
Kann mir da jmd weiterhelfen?
 
Dein Code sortiert schon, allerdings erst ab dem 2. Element (bei 3,1,5 ändert sich also nichts, weil 1,5 bereits sortiert ist; wenn Du 3,5,1 als Liste verwendest, wirst Du sehen, dass 3,1,5 rauskommt). Grund: Deine while-Schleife geht nicht bis zum ersten Element (siehe Kommentar #31 von @temi). Das ist alles.
 
i >= 0 ist richtig (in seinem Code, s. Kommentar #18), denn auch das erste Element muss ggf. nach hinten verschoben werden, falls es größer als das "einzufügende" ist.
 
A

Anzeige




Vielleicht hilft dir das hier weiter: (klicke hier)
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben