# Collection.sort Probleme bei DoubleKO Turniersystem



## .Domii (22. Mai 2011)

Ich programmiere nun seit geraumer Zeit an einem Turnierverwaltungsprogramm. Die SingleKO Funktion war ja schnell implementiert, einfach einbisschen rekursiv und fertig. Nun jedoch, bei der DoubleKO Funktion, stehe ich vor einem Problem. Ich bräuchte eine Sort Funktion (eben die von Collection.sort) jedoch sagt mir NetBeans:

no suitable method found for sort(java.util.LinkedList<Entities.DoubleKOTreeNode>)
    method java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<? super T>) is not applicable
      (cannot instantiate from arguments because actual and formal argument lists differ in length)
    method java.util.Collections.<T>sort(java.util.List<T>) is not applicable
      (inferred type does not conform to declared bound(s)
        inferred: Entities.DoubleKOTreeNode
        bound(s): java.lang.Comparable<? super Entities.DoubleKOTreeNode>)
----
(Alt-Enter shows hints)

der DoubleKOTreeNode ist quasi das Spiel in dem alles abläuft. Nun meine Frage: Braucht Collection.sort eine Art Schlüssel/Nummer/Index nachdem es sortieren kann? D.h. ich müsste in DoubleKOTreeNode soetwas anlegen aber wie?

Hier der Source zur DoubleKOFunktion:

```
package Logik;

import Entities.*;
import java.util.LinkedList;
import java.util.Collections;
import java.util.List;

public class DoubleKO{

    public void createDoubleTree(DoubleKOTreeNode rootWT, DoubleKOTreeNode rootLT, int anzTeilnehmer) {
        DoubleKOTreeNode rootLoseTree2 = new DoubleKOTreeNode(), finale = new DoubleKOTreeNode();
        rootWT.setWinner(finale);
        rootLT.setWinner(finale);
        rootLoseTree2.setWinner(rootLT);

        List<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
        l.add(rootLoseTree2);
        rootLT.setVorherigeSpieleWinner(l);
        l = new LinkedList<DoubleKOTreeNode>();
        l.add(rootLT);
        l.add(rootWT);
        finale.setVorherigeSpieleWinner(l);

        createSingleTree(rootWT, anzTeilnehmer);
        rekcreateRawTree(rootLT, anzTeilnehmer, 1);

        
        setLeftPaths(rootWT, rootLT);
    }

    private void rekcreateRawTree(DoubleKOTreeNode s, int anzTeilnehmer, int lvl) {
        if (anzTeilnehmer > Math.pow(2, lvl + 1)) {
            DoubleKOTreeNode s1 = new  DoubleKOTreeNode(),
                    s2 = new  DoubleKOTreeNode(),
                    s11 = new  DoubleKOTreeNode(), 
                    s22 = new DoubleKOTreeNode(), 
                    spiel = s.getVorherigeSpieleWinner().get(0);
            

            s1.setWinner(spiel);
            s2.setWinner(spiel);
            s11.setWinner(s1);
            s22.setWinner(s2);
            List<DoubleKOTreeNode> ss = new LinkedList<DoubleKOTreeNode>();
            ss.add(s1);
            ss.add(s2);
            spiel.setVorherigeSpieleWinner(ss);
            ss = new LinkedList<DoubleKOTreeNode>();
            ss.add(s11);
            s1.setVorherigeSpieleWinner(ss);
            ss = new LinkedList<DoubleKOTreeNode>();
            ss.add(s22);
            s2.setVorherigeSpieleWinner(ss);

            rekcreateRawTree(s1, anzTeilnehmer, lvl + 1);
            rekcreateRawTree(s2, anzTeilnehmer, lvl + 1);
        }
    }

    private  void setLeftPaths(DoubleKOTreeNode rootWT, DoubleKOTreeNode rootLT) {

        int lvls = countLVLs(rootWT);

        LinkedList<DoubleKOTreeNode> spieleWT = new LinkedList<DoubleKOTreeNode>(); //Spiele eines LVLs im WinnerTree
        retrieveSpieleOfLVL(rootWT, spieleWT, lvls);

        LinkedList<DoubleKOTreeNode> spieleLT = new LinkedList<DoubleKOTreeNode>(); //Spiele eines LVLs im LoserTree
        retrieveSammelSpieleOfLVL(rootLT, spieleLT, lvls - 1);
        Collections.sort(spieleWT);
        Collections.sort(spieleLT);
        

        //erste Verlierer-Verbindung der Trees
        int k = 0;
        for (DoubleKOTreeNode samml : spieleLT) {
            DoubleKOTreeNode s1 = spieleWT.get(k++);
            DoubleKOTreeNode s2 = spieleWT.get(k++);
            s1.setLoser(samml);
            s2.setLoser(samml);
            LinkedList<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
            l.add(s1);
            l.add(s2);
            samml.setVorherigeSpieleLoser(l);
        }

        int lvl = 1;
        for (int i = lvls - 1; i != 0; i--) {
            spieleWT = new LinkedList<DoubleKOTreeNode>();
            spieleLT = new LinkedList<DoubleKOTreeNode>();
            retrieveSpieleOfLVL(rootWT, spieleWT, i);
            retrieveVereinigungsSpieleOfLVL(rootLT, spieleLT, i);
            Collections.sort(spieleWT);
            Collections.sort(spieleLT);


            if (lvl % 2 == 1) {
                int j = spieleLT.size() - 1;
                for (DoubleKOTreeNode s : spieleWT) {
                    s.setLoser(spieleLT.get(j));
                    LinkedList<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
                    l.add(s);
                    spieleLT.get(j).setVorherigeSpieleLoser(l);
                    j--;
                }

            } else {
                for (int j = 0; j < spieleWT.size() / 2; j++) {
                    DoubleKOTreeNode wt = spieleWT.get(j);
                    DoubleKOTreeNode lt = spieleLT.get(((spieleLT.size() / 2) - 1) - j);

                    wt.setLoser(lt);
                    LinkedList<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
                    l.add(wt);
                    lt.setVorherigeSpieleLoser(l);
                }
                for (int j = spieleWT.size() / 2; j < spieleWT.size(); j++) {
                    DoubleKOTreeNode wt = spieleWT.get(j);
                    DoubleKOTreeNode lt = spieleLT.get((spieleLT.size()) - (j - ((spieleLT.size() / 2) - 1)));

                    wt.setLoser(lt);
                    LinkedList<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
                    l.add(wt);
                    lt.setVorherigeSpieleLoser(l);
                }

            }
            lvl++;
        }

    }

   
    public void retrieveSammelSpieleOfLVL(DoubleKOTreeNode spiel, List<DoubleKOTreeNode> ss, int lvl) {
        ss.clear();
        spiel.getVorherigeSpieleWinner();
        rekretrieveSammelSpieleOfLVL(spiel.getVorherigeSpieleWinner().get(0), ss, lvl, 1);
    }
    private  void rekretrieveSammelSpieleOfLVL(DoubleKOTreeNode spiel, List<DoubleKOTreeNode> ss, int sollLVL, int istLVL) {

        if (sollLVL == istLVL) {
            ss.add(spiel);
        } else {
            for (DoubleKOTreeNode s : spiel.getAlleVorherigenSpiele()) {
                rekretrieveSammelSpieleOfLVL(s.getVorherigeSpieleWinner().get(0), ss, sollLVL, istLVL + 1);
            }
        }
    }
    public void retrieveVereinigungsSpieleOfLVL(DoubleKOTreeNode spiel, LinkedList<DoubleKOTreeNode> ss, int lvl) {
        ss.clear();
        rekretrieveVereinigungsSpieleOfLVL(spiel, ss, lvl, 1);
    }
    private void rekretrieveVereinigungsSpieleOfLVL(DoubleKOTreeNode spiel, LinkedList<DoubleKOTreeNode> ss, int sollLVL, int istLVL) {

        if (sollLVL == istLVL) {
            ss.add(spiel);
        } else {
            for (DoubleKOTreeNode s : spiel.getVorherigeSpieleWinner().get(0).getAlleVorherigenSpiele()) {
                rekretrieveVereinigungsSpieleOfLVL(s, ss, sollLVL, istLVL + 1);
            }
        }
    }
    
    
    
    
    
    //SingleTreeStuff ----------------------------------------------------------------------
    
    public void createSingleTree(DoubleKOTreeNode root, int anzTeilnehmer) {
        rekCreateSingleTree(root, anzTeilnehmer, 2);
    }
    private void rekCreateSingleTree(DoubleKOTreeNode Spiel, int anzTeilnehmer, int lvl) {
        if (anzTeilnehmer > Math.pow(2, lvl)) {
            Spiel s1 = new Spiel();
            Spiel s2 = new Spiel();
            s1.setLvl(lvl);
            s2.setLvl(lvl);
            DoubleKOTreeNode t1 = new DoubleKOTreeNode(s1);
            DoubleKOTreeNode t2 = new DoubleKOTreeNode(s2);
            List<DoubleKOTreeNode> l = new LinkedList<DoubleKOTreeNode>();
            l.add(Spiel);
            t1.setVorherigeSpieleWinner(l);
            t2.setVorherigeSpieleWinner(l);
            l = new LinkedList<DoubleKOTreeNode>();
            l.add(t1);
            l.add(t2);
            Spiel.setVorherigeSpieleWinner(l);
            rekCreateSingleTree(t1, anzTeilnehmer, lvl + 1);
            rekCreateSingleTree(t2, anzTeilnehmer, lvl + 1);
        }
    }
    public  int countLVLs(DoubleKOTreeNode root) {
        return rekcountLVLs(root, 1);
    }
    private int rekcountLVLs(DoubleKOTreeNode root, int lvl) {
        if (root.getAlleVorherigenSpiele().isEmpty()) {
            return lvl;
        } else {
            return rekcountLVLs(root.getAlleVorherigenSpiele().get(0), lvl + 1);
        }
    }
    public void retrieveSpieleOfLVL(DoubleKOTreeNode spiel, LinkedList<DoubleKOTreeNode> ss, int lvl) {
        ss.clear();
        rekretrieveSpieleOfLVL(spiel, ss, lvl, 1);
    }
    private void rekretrieveSpieleOfLVL(DoubleKOTreeNode spiel, LinkedList<DoubleKOTreeNode> ss, int sollLVL, int istLVL) {

        if (sollLVL == istLVL) {
            ss.add(spiel);
        } else {
            for (DoubleKOTreeNode s : spiel.getAlleVorherigenSpiele()) {
                rekretrieveSpieleOfLVL(s, ss, sollLVL, istLVL + 1);
            }
        }
    }
}
```

--------------------------------------

Hier noch der Source zu DoubleKOTreeNode:

```
package Entities;

import java.util.LinkedList;
import java.util.List;

public class DoubleKOTreeNode {
    DoubleKOTreeNode winner;
    DoubleKOTreeNode loser;    
    List<DoubleKOTreeNode> winnernode;
    List<DoubleKOTreeNode> losernode;
    Spiel thisplay;
    
    
    public DoubleKOTreeNode() {
    }

    public DoubleKOTreeNode(DoubleKOTreeNode treenode, Spiel thisplay) {
        this.thisplay=thisplay;

        if(winner!=null){
            this.winner= treenode;
        }
        else{
            this.loser= treenode;
        }
        
    }

    public DoubleKOTreeNode(Spiel thisplay) {
        this.thisplay = thisplay;
    }


    public void setVorherigeSpieleWinner(List<DoubleKOTreeNode>l )
    {
        winnernode=l;
    }
   
    public List<DoubleKOTreeNode> getVorherigeSpieleWinner(){
        return winnernode;
    }
    
    public void setVorherigeSpieleLoser(List<DoubleKOTreeNode> l)
    {
        losernode = l;
    }
    public List<DoubleKOTreeNode> getVorherigeSpieleLoser(){
        return losernode;
    }
    public DoubleKOTreeNode(DoubleKOTreeNode rechts, DoubleKOTreeNode links, Spiel thisplay) {
        this.winner = rechts;
        this.loser = links;
        this.thisplay = thisplay;
    }

    public DoubleKOTreeNode getLoser() {
        return loser;
    }

    public void setLoser(DoubleKOTreeNode links) {
        this.loser = links;
    }

    public DoubleKOTreeNode getWinner() {
        return winner;
    }

    public void setWinner(DoubleKOTreeNode rechts) {
        this.winner = rechts;
    }

    public Spiel getThisplay() {
        return thisplay;
    }

    public void setThisplay(Spiel thisplay) {
        this.thisplay = thisplay;
    }

    public List<DoubleKOTreeNode> getWinnernode() {
        return winnernode;
    }
    
    public List<DoubleKOTreeNode> getAlleVorherigenSpiele(){
        List<DoubleKOTreeNode> vorher = new LinkedList<DoubleKOTreeNode>(winnernode);
        for (DoubleKOTreeNode s : this.losernode) {
            vorher.add(s);
        }
        return vorher;
    }
}
```


Falls jemand eine andere Herangehensweise an dieses Turnierverwaltungsprogramm hat wäre ich demjenigen sehr dankbar mir seine Idee hier zu erörtern!

Mfg .Domii


----------



## mvitz (22. Mai 2011)

Entweder deine Klasse Entities.DoubleKOTreeNode muss Comparable<Entities.DoubleKOTreeNode> sein, dann reicht

Collections.sort(deineListe);

ansonsten musst du einen Comparator<Entities.DoubleKOTreeNode> schreiben, der weiß wie er Entities.DoubleKOTreeNode sortiert und 

Collections.sort(deineListe, new DeinComparator());

nutzen.


----------



## eRaaaa (22. Mai 2011)

.Domii hat gesagt.:


> Nun meine Frage: Braucht Collection.sort eine Art Schlüssel/Nummer/Index nachdem es sortieren kann? D.h. ich müsste in DoubleKOTreeNode soetwas anlegen aber wie?



Naja, woher soll die Methode wissen wie sie deine eigene Klasse/bzw Objekte dieser sortieren soll? Das musst du schon festlegen und das macht man entweder über Comparable oder einen Comparator. Hier gibt`s Lesestoff :rtfm:


----------



## .Domii (22. Mai 2011)

Ich sag schonmal Danke ;]
und werd mich mal einlesen.

------
Edit:

Habe die Schnittstelle Comparable<...> implementiert und diese Methode geschrieben zusätzlich noch in DoubleKOTreeNode eine ID durchrasseln lassen und Fertig.

```
@Override
    public int compareTo(Spiel o) {
        if (this.id > o.id) {
            return 1;
        } else if (this.id < o.id) {
            return -1;
        } else {
            return 0;
        }
    }
```


----------

