# Sortieren in einer Queue funktioniert nicht.



## CrazIbiza (24. Jun 2014)

Hallo an die Community,

Ich sitze seit Stunden verzweifelt vor meinem Code.
Ich habe eine Queue programmiert und möchte in dieser nun die Knoten sortieren.
Ich habe eine "Tauschen"-Methode, welche auch einwandfrei funktioniert, aber der Sortieralgorithmus (Bubble Sort) macht was er will.

Hier der Quellcode der Tauschen-Methode:


```
public void swap(int x, int y){
        if(y<x){
            int dummey = x;
            x=y;
            y=dummey;
        }
        Node a = getHead();
        Node b = getHead();
        Node dummy;

        for (int j = 0; j<x-1; j++){            
            a = a.next();                
        }
        for (int j = 0; j<y-1; j++){            
            b = b.next();                
        }

        if(x>1&&y<amount()){
            dummy = b.next();
            b.setNext(a.next());
            a.setNext(b);
            getNode(x).setNext(b);
            getNode(y).setNext(a);
            a.setNext(dummy);
        }
        if(x==1&&y<amount()){
            dummy = b.next();
            b.setNext(a.next());
            head = b;
            Node c = getNode(y-1);

            c.setNext(a);
            a.setNext(dummy);
        }
        if(y==amount()&&x>1){
            b.setNext(a.next());
            getNode(x).setNext(b);
            Node c = getNode(y);

            c.setNext(a);
            a.setNext(a);
            tail = a;
        }
        if(y==amount() && x==1){
            b.setNext(a.next());
            head = b;
            Node c = getNode(y);

            c.setNext(a);
            a.setNext(a);
            tail = a;
        }

    }
```

Und hier der Code des Sortier-Algorithus:


```
public void Sort()
    {
        for(int i=0; i<amount(); i++)
            for(int j=0; j<amount(); j++)
            {         
                if(getContent(j) < getContent(j+1)) 
                {
                    swap(j,j+1);
                }
        }
    }
```

Ich hoffe die Namen der Methoden wie z.B. amount() erklären deren Funktion.
Ansonsten einfach fragen.

Sobald ich die Methode zum Sortieren aufrufe, werden mehrere Zahlen getauscht, jedoch nicht sortiert.

Ich hoffe, dass ihr mir helfen könnt! :idea:

Grüße,
CrazIbiza


----------



## turtle (24. Jun 2014)

> Ich habe eine Queue programmiert und möchte in dieser nun die Knoten sortieren.


Wie kommst du auf die Idee eine Queue sortieren zu wollen?

Eine Queue ist eine Warteschlange. Wenn du schon mal in einer gestanden hast, weisst du, das man sich an einem Ende anstellt und die andere Seite bedient wird. Dieses Prinzip nennt sich FIFO, First In- First out. Also, der sich als Erster anstellt, kommt auch als Erster dran.

Daher macht Sortieren IMHO wenig Sinn.

ICH würde eine *List *nehmen und diese sortieren.

Weiterhin nutzt du in deinem Code die Klasse Node und die hat nun weder mit Queue, noch Sortieren, sondern vielmehr mit XML zu tun.???:L

Ich rate dir, das zu überdenken und da ich Fan von TDD bin, schreibe ich einen Test und "ausnahmsweise" implementiere ich das sogar für dich.

```
import static org.junit.Assert.*;

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

import org.junit.Test;

public class SortInteger {

	@Test
	public void test() {
		List<Integer> list = new ArrayList<>();
		list.add(20);
		list.add(5);
		list.add(21);
		list.add(35);
		Sorter.bubbleSort(list);
		assertEquals(4, list.size());
		assertTrue(5 == list.get(0));
		assertTrue(20 == list.get(1));
		assertTrue(21 == list.get(2));
		assertTrue(35 == list.get(3));
	}
}

class Sorter {

	public static void bubbleSort(List<Integer> list) {
		int size = list.size();
		for (int i = 0; i < size; i++)
			for (int j = 0; j < size; j++) {
				if (list.get(i) < list.get(j)) {
					swap(list, i, j);
				}
			}
	}

	private static void swap(List<Integer> list, int i, int j) {
		Integer int1 = list.get(i);
		Integer int2 = list.get(j);
		list.set(i, int2);
		list.set(j, int1);
	}
}
```


----------



## CrazIbiza (24. Jun 2014)

Hallo turtle,

Danke für deine Mühe, aber leider ist das Sortieren der Queue nicht meine Idee gewesen, sondern auf der Checkliste bei diesem Projekt, welche unser Lehrer uns gegeben hat. :/

Die Klasse Node ist übrigens selber geschrieben bzw. war vorgegeben, das ganze Projekt basiert auf den Abitur-Listenklassen 2012.

Hier der Quellcode:


```
package abiturklassen.listenklassen;

public class Node
{
    public Object content;
    public Node nextNode;

    /**
     * Es wird ein neuer Knoten erzeugt.
     * 
     * @param pContent das Inhaltsobjekt
     * @param pNext der Nachfolgeknoten
     */
    public Node(Object pContent, Node pNext)
    { content = pContent;
        nextNode = pNext;
    }

    /**
     * Das Inhaltsobjekt wird ge&auml;ndert.
     * 
     * @param pContent das neue Inhaltsobjekt
     */
    public void setContent(Object pContent)
    { 
        content = pContent;
    }

    /**
     * Das Inhaltsobjekt wird zur&uuml;ckgegeben.
     * 
     * @return das Inhaltsobjekt
     */
    public Object content()
    {
        return content;
    }

    /**
     * Der Nachfolgeknoten wird ge&auml;dert.
     * 
     * @param pNext der neue Nachfolgeknoten
     */
    public void setNext(Node pNext)
    { 
        nextNode = pNext;
    }

    /**
     * Der Nachfolgeknoten wird zur&uuml;ckgegeben.
     * 
     * @return der Nachfolgeknoten
     */
    public Node next()
    {
        return nextNode;
    }
}
```


Grüße,
CrazIbiza


----------



## ChristianK (25. Jun 2014)

Dann sag deinem Lehrer, dass er Blödsinn unterrichtet. Wer eine Queue sortieren will macht einen groben Denkfehler.

Btw: Den Code, den du zeigst, zeigt mehr eine LinkedList als eine Queue.


----------

