# Zufallszahlen, in einem Diagramm sortieren.



## keksmafia (10. Apr 2008)

```
class ZufallsButtonListener implements ActionListener {	
    
    public void actionPerformed(ActionEvent e){						
    	   	
Graphics g = getGraphics();    	  
String tmp ="";                                              
for (int i=0; i<15; i++) {                               
x[i] = (int)(Math.random() * 100);						
System.out.println(x[i]);                                   
tmp += " | " + x[i];                                       

}
   	      zufallsZ.setText(tmp);
   	         
//--------------------------------------------------------------------------------------------------------------------   		
		int balkenAbstand1 = 15;
		int height1 =20;
		int xPosStart1 = 15;
                int yPosStart1 =290;		
		g.setColor(Color.white);
		g.fillRect(0,0, 700,700);
		
		g.setColor(Color.black);
		g.drawLine(350,0,350,700);
                g.drawLine(0,350,700,350);		
		
		g.setColor(Color.red);
		for(int i=0; i<15; i++)
		{
			xPosStart1 += balkenAbstand1;
			g.fill3DRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 10, height1 * x[i]/10, true);
			
}
}
```

Also soweit wie ich bisher bin, werden mir per Buttondruck 15 Zufallszahlen in einem Label ausgegeben (zufallsZ) und diese Zufallszahlen, werden mir auch direkt durch g.fill3DRect als ein Diagramm gezeichnet.
So weit so gut....

Nun soll per Buttondruck (eines anderen Buttons) das Diagramm sortiert werden (also so das man das sieht wie sortiert wird)

Ein Freund hat mir folgenden Code für das Quicksortverfahren gegeben


```
class BQuickButtonListener implements ActionListener {
	    
	    public void actionPerformed(ActionEvent e){


private void meineswapDraw(int[] Array, int swap1, int swap2, int pivot, int leftBorder, int rightBorder)
	{
		meineswap(Array, swap1, swap2);
		
		// Animiert zeichnen, dabei Buffer verwenden
		BufferedImage newGraph =
((Graphics2D)getGraphics()).getDeviceConfiguration().createCompatibleImage(
		getWidth(), getHeight());
		Graphics g = newGraph.getGraphics();
		int balkenAbstand1 = 15;
		int height1 =20;
		int xPosStart1 = 15;
                int yPosStart1 =290;		
		g.setColor(Color.white);
		g.fillRect(0,0, 700,700);
		
		for(int i=0; i<15; i++)
		{
			if(i != pivot)
				g.setColor(Color.red);
			else
				g.setColor(Color.green);
			if(i == swap1 || i == swap2)
				g.setColor(g.getColor().brighter().brighter().brighter());
			
			xPosStart1+= balkenAbstand1 ;
			g.fill3DRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 10, height1 * x[i]/10, true);
			
			g.setColor(Color.black);
			
			if(i == leftBorder)
				g.fillRect(xPosStart1, yPosStart1 - height1 * x[i], 3, height1 * x[i]);
			else if(i == rightBorder)
				g.fillRect(xPosStart1+ 10 - 3, yPosStart1 - height1 * x[i]/10, 3, height1 * x[i]/10);
		}
		
		getGraphics().drawImage(newGraph, 0, 0,this);
		
		try { Thread.sleep(300); } catch(Exception e) { }
	}
	
	// Wichtige Funktionen für Quicksort 
	private void meineswap(int[] Array, int i, int j)
	{
		int tmp = Array[i];
		Array[i] = Array[j];
		Array[j] = tmp;
	}
	
	// Ab hier das eigentliche Quicksort 
	//**** Quicksort-Algorithmus ****
	public void quickSort(int[] Array)
	{
		quickSort(Array, 0, Array.length - 1);
	}
	
	private void quickSort(int[] Array, int left, int right)
	{
		if(right > left)
		{
			int index = left + (int)((right - left) / 2);
			int pivot = Array[index];	//Pivot = ein Element nehmen
			
			//swap(Array, index, rechts)
			meineswapDraw(Array, index, right, index, left, right);
			index = left;
			for(int i = index; i < right; ++i)
			{
				if(Array[i] < pivot)
					//swap(Array, index++, i)
					meineswapDraw(Array, index++, i, index, left, right);
			}
			//swap(Array, index, rechts)
			meineswapDraw(Array, index, right, index, left, right);
			
			quickSort(Array, left, index);
			quickSort(Array, index + 1, right);
		}
	  }
    }
}
```

Sooo und da bin ich am Ende mit meinem Wissen....
Ich benutze Eclipse und das zeigt mir den Fehler immer bei 





> getGraphics().drawImage(newGraph, 0, 0,this);


 an, könnte mir vllt erstmal einer sagen was dieses drawImage da soll? Ich versuche das erstaml selbst zu verstehen, aber beim drawImage komme ich nicht weiter    :? 

Schon mal danke für eure Antworten
und falls ihr noch irgendwelche Infos dazu braucht, schreibt die Anfragen hier rein


----------



## Marco13 (10. Apr 2008)

Bei jedem swap ein neues Image erstellen?  :autsch:  :autsch:  :autsch:
Vermutlich war das ganze mal eine innere Klasse von einem JPanel oder so, und darauf bezog sich das "getGraphics". Aber getGraphics auf einer Component aufzurufen ist fast immer falsch. 

Speicher' dir den Array, der sortiert werden soll als Field in der Klasse. Die Klasse kann z.B. von JPanel abgeleitet sein. Von diesem JPanel überschreibst du die paintComponent(Graphics g) - Methode, und (NUR) in dieser Methode zeichnest du den aktuellen Arrayzustand.


----------



## Gast (11. Apr 2008)

.....hm  sorry  ist bestimm richtig, aber ich kann mit der antwort nix anfangen

habe keinen JPanel, benutze kein swing....

mache das ganze in einem frame und warum is drawImage falsch???


----------



## Marco13 (11. Apr 2008)

Das gesagt gilt im Wesentlichen auch für ein Panel oder einen Canvas (also für AWT). Dort überschreibt man aber paint(Graphics g), und nicht paintComponent. Kannst dich in gewissen Grenzen vielleicht auch hieran orientieren:
http://java.sun.com/applets/jdk/1.4/demo/applets/SortDemo/example1.html

EDIT: drawImage ist nicht falsch, sondern getGraphics(). Die Methode gibt es (dort) einfach nicht. Nur auf BufferedImages. (Und auf Components aber dort sollte man sie i.a. *NICHT* aufrufen!!!)


----------



## keksmafia (14. Apr 2008)

```
import java.awt.*;																//Import für AWT-Elemente
import java.awt.event.*;														//Import für Events der AWT-Elemente
import java.awt.image.*;
//import java.SortAlgoritm.*;

//--------------------------------------------------------------------------------------------------------------------
public class VisuSort extends Frame {
	
//-----------------------------------------------------------------------------
	//Buttons
	Button bQuick = new Button("Quciksort");									//Quicksort Button erstellen
	Button bBubble= new Button("Bubblesort");									//Bubblesort Button erstellen
	Button bMerg  = new Button("Mergsort");										//Mergsort Button erstellen
	Button bMin   = new Button("Minsort");										//Minsort Button erstellen
	Button zufallsButton = new Button("Zufallszahlen- und Diagrammerstellung");	//Zufallszahlen Button erstellen
	Button bAlle = new Button("Alle sortieren");								//bAlle Button erstellen

	//Label 
	Label lUeberschrift = new Label("Visualisierung von Sortierverfahren");		//Überschrift Label erstellen
	Label zufallsZ = new Label("  Hier kommmen die Zufallszahlen hin");			//Zufallszahlenpool Label erstellen
		
//-----------------------------------------------------------------------------
	//Festlegung der Abstände
	int länge = 700/7;							 //Abstand zur Seite
	int höhe = 700/7;							 //Abstand zur Decke
		
	//Festlegung der Höhe und Breite der Buttons 
	int bhoe = 20;								 //Höhe der Buttons
	int bbrei = 100;							 //Breite der Buttons
	
	//Festlegung von Sonstigem
	public int x[]= new int[500];				 //Variable für Random    
	
//-----------------------------------------------------------------------------
	//Schriftarteinstellung
	Font lUeberschriftfont = new Font("Serif", Font.BOLD, 28);		 //Überschrift Schriftart
	Font bQBMM = new Font("Dialog", Font.BOLD, 12);					 //Quicksort etc Schriftart
	Font zufallB = new Font("DialogInput", Font.BOLD, 12);			 //Zufallszahlenlabel Schriftart
	
//---------------------------------------------------------------------------------------------------------------------
	public static void main(String[] args) {
		
		VisuSort viso = new VisuSort();			 //Konstruktoraufruf
		}

//-----------------------------------------------------------------------------
	public VisuSort(){
    	super("VisuSort");						 //Fenstername
    	setSize(700,700);						 //Fenstergröße
    	setLocation(150,25);					 //"Startpunkt" des Programms
       	setLayout(null);						 //Layoutart
    	setVisible(true);						 //Fenster sichtbar machen
    	setResizable(false);					 //Fenstergröße kann nicht verändert werden!!!
    	
//-----------------------------------------------------------------------------
    	addWindowListener(new WindowAdapter() {					//Window
    		public void windowClosing(WindowEvent event){		//Closing
    			System.exit(0);									//Adapter
    		}													//
       	});														//
    	    	
//-----------------------------------------------------------------------------
    	//Labels bounden
       	lUeberschrift.setBounds(länge+20,höhe/4,500,60);			 //Überschrift Label bounden
       	zufallsZ.setBounds(länge/5,höhe+560,600,40);				 //Zufallszahlen Label bounden
    	
    	//Bounden der Buttons
    	bQuick.setBounds(länge/4,höhe+200,bbrei,bhoe);				 //Quicksort Button bounden
       	bBubble.setBounds(länge+475,höhe+200,bbrei,bhoe);			 //Bubblesort Button bounden
       	bMerg.setBounds(länge/4,höhe+500,bbrei,bhoe);				 //Mergsort Button bounden
       	bMin.setBounds(länge+475,höhe+500,bbrei,bhoe);				 //Minsort Button bounden
       	zufallsButton.setBounds(länge/4,höhe+535,bbrei+165,bhoe);	 //Zufallszahlen Button bounden
       	bAlle.setBounds(länge/4*12,höhe+240,bbrei,bhoe);			 //Alle_sortieren Button bounden
       	
//-----------------------------------------------------------------------------
       	//Schriftartverteilung
       	lUeberschrift.setFont(lUeberschriftfont);	  //Überschrift Schirftart
       	zufallsZ.setFont(zufallB);					  //Zufallszahlenpool Schriftart
       	
       	bQuick.setFont(bQBMM);						  //Den Buttons
       	bBubble.setFont(bQBMM);						  //Die Schriftarten
       	bMerg.setFont(bQBMM);						  //zuweisen
       	bMin.setFont(bQBMM);						  //
       	zufallsButton.setFont(bQBMM);				  //
       	bAlle.setFont(bQBMM);						  //
       	
//-----------------------------------------------------------------------------
       	//Alles einfügen
       	add(bQuick); 								  //Quicksort Button einfügen
       	add(bBubble); 								  //Bubblesort Button einfügen
       	add(bMerg); 								  //Mergsort Button einfügen
       	add(bMin);		 							  //Minsort Button einfügen
       	add(zufallsButton);							  //Zufallszahlen Button einfügen
       	add(bAlle);									  //Alle_sortieren Button einfügen
      
     	add(lUeberschrift);							  //Überschrift Label einfügen
     	add(zufallsZ);								  //Zufallszahlen Label einfügen

 //--------------------------------------------------------------------------------     	
     	zufallsButton.addActionListener(new ZufallsButtonListener());	 
     	bQuick.addActionListener(new BQuickButtonListener());
     	bBubble.addActionListener(new BBubbleButtonListener());
     	bMerg.addActionListener(new BMergButtonListener());
     	bMin.addActionListener(new BMinButtonListener());
     	bAlle.addActionListener(new BAlleButtonListener());
     	
	}
	
	public void paint(Graphics g) {
		g.setColor(Color.black);				 //Darunter liegende zu zeichnende Objekte werden schwarz
		g.drawLine(350,0,350,700);				 //Vertikale Linie
		g.drawLine(0,350,700,350);				 //Horizontale Linie
	}

//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------		
//---------------------------------------------------------------------------------------------------------------------
	//Buttoneinstellungen für die Zufallszahlengenerierung im Label zufallsZ und die Erstellung der Diagramme
	class ZufallsButtonListener implements ActionListener {		//Dem Button zufallsButton wird ein Actionlistener hinzugefügt
    
    public void actionPerformed(ActionEvent e){						
    	   	
    	  //quickSort(x);
    	  Graphics g = getGraphics();			 //Nötig, damit durch den Button gezeichnet wird
    	  String abc ="";                        //Erzeugt das Arry abc
 	      for (int i=0; i<15; i++) {            //Forschleife für die Anzahl der Zufallszahlen
 	      x[i] = (int)(Math.random() * 100+1);	 //Speichert die Zufallszahlen in x[i]
 	      System.out.println(x[i]);              //Ausgabe der Zufallszahlen in der Konsole
   	      abc += " | " + x[i];                   //Hängt die Werte von x an tmp dran
   	      }
   	      zufallsZ.setText(abc);                 //Ausgabe der Zufallszahlen im Label zuffallsZ
   	         
//-----------------------------------------------------------------------------
		//Hintergrund für ALLE Diagramme
		g.setColor(Color.white);			//Darunter liegende zu zeichnende Objekte werden weis
		g.fillRect(0,0, 700,700);			//Malt Hintergrund für Diagramm
		
		//Aufteilungskreuz
		g.setColor(Color.black);			//Darunter liegende zu zeichnende Objekte werden schwarz
		g.drawLine(350,0,350,700);			//Vertikale Linie
		g.drawLine(0,350,700,350);			//Horizontale Linie
		
		int balkenAbstand1 = 15;			//Festlegung des Abstandes zwischen den Diagrammbalken
		int height1 =20;					//Höhenfaktor für die Balken
		int xPosStart1 = 15;				//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart1 =290;				//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		//Quicksort Diagramm
		g.setColor(Color.red);				//Darunter liegende zu zeichnende Objekte werden rot
		for(int i=0; i<15; i++)
		{
		xPosStart1 += balkenAbstand1;	//Abstand der Balken
		g.fill3DRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 10, height1 * x[i]/10, true);	
		}
		
//-----------------------------------------------------------------------------
		int balkenAbstand2 = 15;			//Festlegung des Abstandes zwischen den Diagrammbalken
		int height2 =20;					//Höhenfaktor für die Balken
		int xPosStart2 = 440;				//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart2 =290;				//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		//Bubblesort Diagramm
		g.setColor(Color.yellow);			//Darunter liegende zu zeichnende Objekte werden gelb
		for(int i=0; i<15; i++)
		{
			xPosStart2 += balkenAbstand2;
			g.fill3DRect(xPosStart2, yPosStart2 - height2 * x[i]/10, 10, height2 * x[i]/10, true);
			
		}
//-----------------------------------------------------------------------------
		int balkenAbstand3 = 15;			//Festlegung des Abstandes zwischen den Diagrammbalken
		int height3 =20;					//Höhenfaktor für die Balken
		int xPosStart3 = 15;				//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart3 =595;				//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		//Mergsort Diagramm
		g.setColor(Color.green);			//Darunter liegende zu zeichnende Objekte werden grün
		for(int i=0; i<15; i++)
		{
			xPosStart3 += balkenAbstand3;
			g.fill3DRect(xPosStart3, yPosStart3 - height3 * x[i]/10, 10, height3 * x[i]/10, true);
			
		}
//-----------------------------------------------------------------------------
		int balkenAbstand4 = 15;			//Festlegung des Abstandes zwischen den Diagrammbalken
		int height4 =20;					//Höhenfaktor für die Balken
		int xPosStart4 = 440;				//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart4 =595;				//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		//Minsort Diagramm
		g.setColor(Color.blue);				//Darunter liegende zu zeichnende Objekte werden blau
		for(int i=0; i<15; i++)
		{
			xPosStart4 += balkenAbstand4;
			g.fill3DRect(xPosStart4, yPosStart4 - height4 * x[i]/10, 10, height4 * x[i]/10, true);
			}
		
	}//ActionPerformed von Zufallszahlen- und Diagrammerstellung ENDE
}//ActionListener von Zufallszahlen- und Diagrammerstellung ENDE

//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
class BQuickButtonListener implements ActionListener {
	    
	    public void actionPerformed(ActionEvent e){
	    	
	    quickSort(x); //Aufruf von Quicksort (Quicksortdefinierung fängt weiter unten an)
	    		    	
		}//ActionPerformed von Quicksort ENDE
}//ActionListener von Quicksort ENDE


public void vergleicheDraw(int[] Array, int vergleiche1, int vergleiche2, int pivot, int linkeSeite, int rechteSeite)
	{
		vergleiche(Array, vergleiche1, vergleiche2);
		
		// Animiert zeichnen, dabei Buffer verwenden
		//BufferedImage newGraph = BufferedImage((Graphics2D)getGraphics()).getDeviceConfiguration().createCompatibleImage(
		//getBalkenAbstand1(), getBalkenHöhe1(), Transparency.TRANSLUCENT);
		//
		//Graphics g = newGraph.getGraphics();
		Graphics g = getGraphics();
		//g.setColor(Color.orange);		
		//g.fillRect(0,0, 350,350);
		g.clearRect(0,0,350,350);
		
		int balkenAbstand1 = 15;		
		int balkenHöhe1 =20;				
		int xPosStart1 = 15;			
		int yPosStart1 =290;
		
		for(int i=0; i<15; i++)
		{
			if(i != pivot)
				g.setColor(Color.red);
			else
				g.setColor(Color.yellow);
			if(i == vergleiche1 || i == vergleiche2)
				g.setColor(g.getColor().brighter().brighter().brighter());
			
			xPosStart1 += balkenAbstand1;
			g.fill3DRect(xPosStart1, yPosStart1 - balkenHöhe1 * x[i]/10, 10, balkenHöhe1 * x[i]/10, true);
			
			g.setColor(Color.black);
			
			if(i == linkeSeite)
				g.fillRect(xPosStart1, yPosStart1 - balkenHöhe1 * x[i]/10,5, balkenHöhe1 * x[i]/10);
			else if(i == rechteSeite)
				g.fillRect(xPosStart1+7 /*+ 10 - 3*/, yPosStart1 - balkenHöhe1 * x[i]/10, 5, balkenHöhe1 * x[i]/10);
		}
		
		//getGraphics().drawImage(newGraph,0, 0, this);
		
		try { Thread.sleep(500); } catch(Exception e) { }
	}
	
	// Wichtige Funktionen für Quicksort 
	private void vergleiche(int[] Array, int i, int j)
	{
		int abc = Array[i];
		Array[i] = Array[j];
		Array[j] = abc;
	}
	
	// Ab hier das eigentliche Quicksort 
	//**** Quicksort-Algorithmus *************************************
	public void quickSort(int[] Array)
	{
		quickSort(Array, 0, Array.length -1 );
	}
	
	private void quickSort(int[] Array, int links, int rechts)
	{
		if(rechts > links)
		{
			int index = links + (int)((rechts - links)/ 2);
			int pivot = Array[index];	//Pivot = ein Element nehmen
			
			//vergleiche(Array, index, rechts)
			vergleicheDraw(Array, index, rechts, index, links, rechts);
			index = links;
			for(int i = index; i < rechts; ++i)
			{
				if(Array[i] < pivot)
					//vergleiche(Array, index++, i)
					vergleicheDraw(Array, index++, i, index, links, rechts);
			}
			//vergleiche(Array, index, rechts)
			vergleicheDraw(Array, index, rechts, index, links, rechts);
			
			quickSort(Array, links, index);
			quickSort(Array, index + 1, rechts);
			
			
		}
	}


//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
class BBubbleButtonListener implements ActionListener {
	    
	    public void actionPerformed(ActionEvent e){
	    	
		}//ActionPerformed von Bubblesort ENDE
}//ActionListener von Bubblesort ENDE

//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
class BMergButtonListener implements ActionListener {
    
    	public void actionPerformed(ActionEvent e){
    	
		}//ActionPerformed von Mergsort ENDE    
}//ActionListener von Mergsort ENDE

//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
class BMinButtonListener implements ActionListener {
    
    	public void actionPerformed(ActionEvent e){
    	
    	
    	
		}//ActionPerformed von Minsort ENDE  
}//ActionListener von Minsort ENDE

//---------------------------------------------------------------------------------------------------------------------
//Button---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
class BAlleButtonListener implements ActionListener {
    
    	public void actionPerformed(ActionEvent e){
    	
    	
		}//ActionPerformed von Alle_sortieren ENDE  
}//ActionListener von Alle_sortieren ENDE

//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------


//---------------------------------------------------------------------------------------------------------------------
}//Alles zu
```

hm das wollte ich eigentlich nicht machen (kompletten code reinstellen), aber komme gar nicht weiter......

bin soweit, das per buttondruck mehr oder weniger sortiert wird (beim button Quicksort), aber irgendwie werden manche balken vom diagramm einfach mal so übermalt.....

weis einer warum????

zeile 205 bis 300 für quicksort


----------



## SlaterB (14. Apr 2008)

du hast in deinem Code
> Graphics g = getGraphics();          
und damit eh in jeder Hinsicht verloren,

deine paint-Operation und deine sonstigen Zeichenoperation arbeiten unkoordiniert durcheinander,
da kann alles mögliche schlimme passieren


----------



## qlimax (14. Apr 2008)

*hi keksmafia*,

wollte auch nen Thread deswegen öffnen aber wenn du schon hast =) dann is ja ok 

hoffe uns wird hier geholfen.


----------



## keksmafia (14. Apr 2008)

hm ok

@SlaterB

was soll ich denn sonst verwenden????
weil, würde ja nicht hier posten, wenn ich selber weiter wüsse -.-


----------



## Marco13 (14. Apr 2008)

Marco13 hat gesagt.:
			
		

> Speicher' dir den Array, der sortiert werden soll als Field in der Klasse. *Die Klasse kann z.B. von JPanel abgeleitet sein. Von diesem JPanel überschreibst du die paintComponent(Graphics g) - Methode, und (NUR) in dieser Methode zeichnest du den aktuellen Arrayzustand.*


----------



## SlaterB (14. Apr 2008)

ich würds ja posten, wenns hier nicht schon im Thread stände 

aber ok, Marco13 hats vielleicht nicht überdeutlich gemacht:
NIEMALS getGraphis() aufrufen, 
sondern paint überschreiben und nur in paint zeichnen,

dein ActionListener hat was zu vermelden zum paint?
gut, dann setze irgeneine boolean-Variable/ merke irgendwelche anderen Zustände,
rufe repaint() auf
und paint wird anhand der Exemplarvariablen/ Klassenattribute das richtige zeichnen


----------



## qlimax (14. Apr 2008)

@SlaterB

also getGraphics() raus ... & mit repaint das Diagramm überschreiben...

ja der ActionListener sollte ja dann das erstellte Diagramm Sortieren mit den Algorithmus.

nur wenn man diesen hier ausführt dann malt er zwar  nur nich mit den erstellten Diagramm :x

könntest du mal vielleicht iwie nen kleinen Ansatz im Quellcode machen :x das wäre ne große hilfe 

gruß qlimax


----------



## SlaterB (14. Apr 2008)

Button b ändert die Zeichnung von 4 auf 5:

```
public class TestGUI
    extends JFrame
{
    private int k = 4;

    public TestGUI()
        throws Exception
    {
        JButton b = new JButton("Test");
        b.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    k = 5;
                    repaint();
                }
            });
        JPanel p = new JPanel()
            {
                protected void paintComponent(Graphics g)
                {
                    super.paintComponent(g);
                    g.drawString("" + k, 30, 30);

                }
            };

        add(p, BorderLayout.CENTER);
        add(b, BorderLayout.SOUTH);

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(500, 200);
        setVisible(true);
    }

    public static void main(String[] args)
        throws Exception
    {
        new TestGUI();
    }
}
```


----------



## qlimax (14. Apr 2008)

@SlaterB

hey das sieht gut aus... nur leider müssen wir das als Frame & nicht als JFrame machen :x

aber ich glaube das dürfte kein Problem sein oder?

aber danke erstmal =) vielleicht kannst du es ja auf ein Frame beziehen :>

gruß Qlimax


----------



## SlaterB (14. Apr 2008)

das Beispiel war schon einer Überbeanspruchung,
wenn du selber nicht mal ein Frame mit Button und Panel zusammenbauen kannst,
dann lohnt sich das alles eh nicht 

allein um paint könnten noch Fragen offen sein,
aber da muss ja eh erstmal ein Tutorial her, bzw. wie schon geschrieben:



			
				Marco13 hat gesagt.:
			
		

> Das gesagt gilt im Wesentlichen auch für ein Panel oder einen Canvas (also für AWT). Dort überschreibt man aber paint(Graphics g), und nicht paintComponent. Kannst dich in gewissen Grenzen vielleicht auch hieran orientieren:
> http://java.sun.com/applets/jdk/1.4/demo/applets/SortDemo/example1.html


----------



## qlimax (14. Apr 2008)

ja doch das ist ja kein Problem sowas zu erstellen 

naja ich werde mich mal dran setzen. 

Hab nur gedacht dann müsste ich nicht wieder von ganz vorne Anfangen.

gruß Qlimax


----------



## keksmafia (14. Apr 2008)

hey da sind wir ja schon ganz schön vorran gekommen (also ihr ^^)
nur gibt es da ein problem, ich versteh nix von funktionen usw, wo was welches dingen repaintet oder so.....
könntet ihr nicht einmal ne ausnhame machen, und den quelltext so wie ich den da oben gepostet habe verändern???

verstehe so fast nix von dem was ihr oben gepostet hat, und für euch wohl hilfreiche ratschläge deprimieren mich nur noch mehr, da ich nichts davon umsetzten kann..... (sollte wohl noch dazu schreiben, das ich gerade anfange)


----------



## keksmafia (14. Apr 2008)

so btw....warum hört das prog nicht auf zu sortieren?????


----------



## Marco13 (14. Apr 2008)

Ich kapier' das ja nicht ???:L  Hauptsache mal mit
Font bQBMM = new Font("Dialog", Font.BOLD, 12);                //Quicksort etc Schriftart 
irgendwelche tollen Fonts gesetzt und mit
bAlle.setBounds(länge/4*12,höhe+240,bbrei,bhoe);          //Alle_sortieren Button bounden 
irgendwelchen bbrei geschrieben, aber sich mal 2, 3 Klassen näher anzusehen (wie die in dem Verklinkten Demo-Applet, das ja schon GENAU das macht, was du willst) ist zu viel verlangt? Hm ???:L


----------



## keksmafia (14. Apr 2008)

ich hab mir die seite angeguckt, bin auch sehr begeistert von den verschiedenen sortierverfahren, aber ich kapier nicht, wie ich diese algorithmen auf die zeichnung anwende......

fonts zu erstellen und dinge zu bounden ist keine große sache.... (selbst nicht für nen anfänger, da könnte ich auch visual basic nutzen....)

nicht zu vergessen, das ich mir auch 8 dieser beispiele runtergeladen habe...... (also auch versucht habe, diese zu verstehen)


----------



## Marco13 (14. Apr 2008)

Hmja, aber wenn du dir mal 
http://java.sun.com/applets/jdk/1.4/demo/applets/SortDemo/SortItem.java
angesehen hättest...: Dort gibt es einen Array, der sortiert wird, eine paint-Methode, die den Array als Balken malt... eigentlich musst du nicht viel mehr machen, als dort "Applet" durch "Frame" zu ersetzen (ein bißchen mehr, aber nicht viel). Woran hakt's denn jetzt?


----------



## qlimax (14. Apr 2008)

es hakt einfach daran das es langsam frustriert ... wir sitzen davor & wir kommen net weiter weil uns einfach die ideen ausgegangen sind & auch die motivation weg ist ....


----------



## Gast (14. Apr 2008)

so btw weis ich nicht, wie man aus nem applet nen frame macht....
und das applet, was du das gepostet hast funzt bei mir nicht (ja ich habs mit appletviewer geöffnet...)


----------



## qlimax (14. Apr 2008)

soweit habe ich es umgeschrieben 2 Errors hab ich noch... aber die krieg ich nicht weg niemals....

naja ich poste euch mal die 2 Dateien ... da der Quellcode ziemlich lang ist....


da blick ich gar nicht mehr durch.. was bringt es mir das komplizierter zu machen als es ist....
es funktioniert nicht.

Ich weiss es ist sowieso schlecht umgeschrieben ... aber naja

mal gucken was ihr dazu sagt...

1.Sortieralgorithmen.java
2.
SortAlgorithm.java/


----------



## Marco13 (14. Apr 2008)

Aaalso - *lufthol*. Was du jetzt mit den beiden Dateien sagen wolltest, ist mir schleierhaft. Das war das verlinkte Applet, wo ein bißchen rum-umbenannt und anderweitig rumgepfuscht wurde.

Frustrierend ist es nur, weil es nicht funktioniert. Die Beantwortung der Frage, WARUM es nicht funktioniert, überlasse ich in erster Näherung dir. (Ich will ja nichts diskreditierendes sagen).

_was bringt es mir das komplizierter zu machen als es ist.... _
Dis bisherigen Antworten zielten darauf ab, es _einfacher_ zu machen, als du es dir bisher (selbst!) gemacht hast. Vielleicht wurde das nicht so deutlich.

_Ein Freund hat mir folgenden Code für das Quicksortverfahren gegeben _
Schön, wenn dein Freund Code für das Quicksortverfahren hat. Das bringt dir aber offenbar nichts, außer, wenn du deinen Freund bittest, dir auch noch das restliche Programm drumrumzustricken. 

Manchmal kommt man - so erschreckend das für dich jetzt im ersten Moment auch erscheinen mag - um's _selbst denken_ nicht drumrum. (Wobei man den Quicksort selbst natürlich ruhig irgendwo abtippen kann, wenn man ihn mal nachvollzogen hat)

Aber mal der Reihe nach:

- Es müssen Balkendiagramme gezeichnet werden
-> Zeichnen!? Das kann man in einer Klasse, die von Panel abgeleitet ist, indem man die paint-Methode überschreibt

- Die Höhen der Balken entsprechen den Zahlen im Array, der sortiert werden soll. 
-> Das Panel muss den array kennen

- Muss noch etwas gezeichnet werden? Das Pivot-Element? Irgendwelche Markierungen?


```
class SortPanel extends Panel
{
    // Felder, die benötigt werden:
    private int array[]; // Der zu sortierende Array
    // ... weitere?

    public void paint(Graphics g)
    {
        super.paint(g);

        g.drawString("Mal mal", 20, 20);

        // Hier werden die Balken gezeichnet.

        // Wie breit müssen die Balken sein?
        // Wie hoch müssen die Balken sein?

        // Was muss noch gezeichnet werden?
    }
}
```

Das ganze soll den Ablauf von einem Sortieralgorithmus veranschaulichen. "Ein" Sortieralgorithmus ist, ganz _abstract_ (sic!) formuliert, ist das irgendwas, was einen Array sortieren kann. 
-> Der Sortieralgorithmus muss den gleichen Array kennen, wie das Panel

Außerdem muss der Sortieralgorithmus dem Panel bescheid sagen, wenn sich was geändert hat, und neu gezeichnet werden muss
-> Der Sortieralgorithmus muss das Panel kennen (nur indirekt, aber direkt ist es einfacher)


```
abstract class SortAlgorithm
{
    private int array[];
    private SortPanel sortPanel;

    public abstract void sort();

    public void notifyThePanel()
    {
        sortPanel.repaint();
        // hier ggf. noch mit Thread.sleep einen Moment warten
    }
}
```
Welcher Algorithmus das am Ende ist, ist egal - da BubbleSort am einfachsten ist, bietet der sich für den Anfang an

```
class BubbleSort extends SortAlgorithm
{
    public void sort()
    {
        // Sortieren, und zwischendurch
        notifyThePanel();
        // aufrufen
    }
}
```



Wenn man das ganze dann in einen Frame packt (minimalistisch, mit einfachem Layout, ohne setBounds und irgendwelchen Font-Schnickschnack, der das ganze nur unübersichtlich (und damit _frustrierend_!!!) macht), hat man schonmal was, was man mit einem Buttonklick starten kann... und das ist ausbaufähig...

```
import java.awt.*;                                                //Import für AWT-Elemente
import java.awt.event.*;                                          //Import für Events der AWT-Elemente
import java.awt.image.*;


class SortPanel extends Panel
{
    private int array[]; // Der zu sortierende Array

    public SortPanel(int a[])
    {
        array = a;
    }

    public void paint(Graphics g)
    {
        super.paint(g);

        g.drawString("Mal mal, array[0]="+array[0], 20, 20);

        // Hier werden die Balken gezeichnet.

        // Wie breit müssen die Balken sein?
        // Wie hoch müssen die Balken sein?

        // WICHTIG: Was muss noch gezeichnet werden?
    }
}


abstract class SortAlgorithm
{
    protected int array[];
    private SortPanel sortPanel;

    public SortAlgorithm(int a[], SortPanel p)
    {
        array = a;
        sortPanel = p;
    }

    public abstract void sort();

    public void notifyThePanel()
    {
        sortPanel.repaint();
        try
        {
            Thread.sleep(100);
        }
        catch (Exception e) {}
    }
}


class BubbleSort extends SortAlgorithm
{
    public BubbleSort(int a[], SortPanel p)
    {
        super(a, p);
    }

    public void sort()
    {
        for (int i=0; i<100; i++)
        {
            array[0] = i;
            notifyThePanel();
        }
    }
}



public class VisuSort2 extends Frame
{
    public static void main(String[] args)
    {
        VisuSort2 viso = new VisuSort2();
    }

    private int array[] = new int[] { 22,3,12,53,63 };
    private SortAlgorithm sortAlgorithm;

    public VisuSort2()
    {
        super("VisuSort");                   //Fenstername
        setSize(700,700);                   //Fenstergröße
        setResizable(false);                //Fenstergröße kann nicht verändert werden!!!

        addWindowListener(new WindowAdapter() {               //Window
           public void windowClosing(WindowEvent event){      //Closing
              System.exit(0);                           //Adapter
           }                                       //
        });                                          //

        setLayout(new BorderLayout());

        add(new Label("Sortierverfahren", Label.CENTER), BorderLayout.NORTH);




        SortPanel sortPanel = new SortPanel(array);
        add(sortPanel, BorderLayout.CENTER);

        sortAlgorithm = new BubbleSort(array, sortPanel);

        Button startButton = new Button("Start");
        add(startButton, BorderLayout.SOUTH);

        startButton.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                execute();
            }
        });


        setVisible(true);                   //Fenster sichtbar machen - ganz am Ende!
   }


   public void execute()
   {
        Thread thread = new Thread(new Runnable()
        {
            public void run()
            {
                sortAlgorithm.sort();
            }
        });
        thread.start();
   }


}
```


----------



## Gast (14. Apr 2008)

hm gibts da nich noch ne viel einfachere lösung??? 

also ihr versteht ja schon sehr viel davon , was keksmafia braucht und meint, aber fürn anfänger scheint das nix zu sein


----------



## Gast (14. Apr 2008)

edit:

denke das sollte ihnen helfen

sry marco13


----------



## qlimax (14. Apr 2008)

Hallo Marco,

vielen vielen dank für deine hilfe =)

das sieht ja schon nach etwas aus  ich werde es versuchen auszubauen....

nur ist es fraglich ob ich das noch in der knappen zeit schaffe... d.h. bis Freitag :roll: 

*denk* *denk* 
dein Quellcode verstehe ich, ist auch super gemacht, hab auch schon bischen gebastelt  nur .....:autsch: 

wir haben nun 01:04 und ich sitze immer noch davor xD
gruß Qlimax


----------



## Gast (15. Apr 2008)

ja das programm zählt von 1 bis 100......

mal gar nichts, sortiert auch nix....


----------



## Marco13 (15. Apr 2008)

Ja, soll ich die Komplettlösung schreiben oder was?  :autsch: Was ich geschrieben hatte, war ein Ansatz - ein Gerüst. Dort müssen ("nur noch") die Balken gezeichnet und z.B. BubbleSort implementiert werden. Wenn das funktioniert, implementiert man noch andere Sortieralgorithmen, und wenn man's richtig gemacht hat, ist das Hinzufügen weiterer Sortieralgorithmen zu dem Porgramm, das _vorher_ nur den BubbleSort angezeigt hat (abgesehen von der Implementierung des Algorithmus selbst, natürlich) mit wenigen Zeilen erledigt. Man braucht dann kein Copy&Paste ganzer Codeblöcke, und kein händisches ausprobieren und tweaken von Zeilen wie
bBubble.setBounds(länge+475,höhe+200,bbrei,bhoe);          //Bubblesort Button bounden 
oder
int yPosStart3 =595;            //Anfang auf der Y-Achse des Ersten Diagrammbalkens 
sondern man könnte das ganze (wenn man's drauf anlegt) tatsächlich so schreiben, dass man bestehende Implementierungen von Sortieralgorithmen mit so einer Zeile wie
myProgramm.addSortAlgorithm(new Quicksort());
hinzufügen kann.
Aber genug geschwärmt :wink:  
Vielleicht posten keksmafia und qlimax ja mal einen Zwischenstand...?


----------



## qlimax (15. Apr 2008)

An deinen Quellcode habe ich noch nicht wirklich was geschafft...
Ich habe versucht mit meinen weiter zu kommen ... aber denke ich sowieso habe ich falsch angefangen ... da ich es Versucht habe mit einen Quicksort.. aber da BubbleSort einfacher ist zu Realisieren da er nur durch 2 Schleifen muss werde ich mich damit versuchen....


Gruß Qlimax

p.s. ich schicke dir mal einen Quellcode der Sortiert aber ich weiss 1. nicht ob es funktionieren würde wenn ich diesen in eine ActionListener tun würde... 

Status: meines Quellcodes: 
http://www.xup.in/dl,10393845/Sortierfunktionen.java/

was macht diese Zeile: ((Graphics2D)getGraphics()).getDeviceConfiguration().createCompatibleImage(
getWidth(), getHeight());
und warum die Meldung: Sortierfunktionen.java uses or overrides a deprecated API.

=> Hab gemerkt wenn ich das show(); weg mache dann kommt diese Meldung nicht mehr doch zeigt er mir auch nix mehr an  nicht mal das Frame.

Hab mal mit setVisible(true); dann geht das  

Er sortiert per ButtonKlick das is guuuuuuut!  *freu*


----------



## qlimax (15. Apr 2008)

panel im arsch  :lol: 

es geht auch ohne


----------



## keksmafia (15. Apr 2008)

Is noch ne Menge auskommentiert, ergibt manches aus so keinen sinn, da es nur platzhalter sind, oder auskommentierte tests

ABER so sollte es sein!!!!


```
import java.awt.*;					  // Import für AWT-Elemente
import java.awt.event.*;			  // Import für Events der AWT-Elemente
import java.util.Random; 			  // Import für die Zufallszahlen			  
import java.awt.image.*;			  // Import für images der AWT-Elemente			  	  

public class VisualisierungVonSortierverfahren extends Frame
{
	//-----------------------------------------------------------------------------
	//Buttons
	Button bQuick = new Button("Quciksort");									//Quicksort Button erstellen
	Button bBubble= new Button("Bubblesort");									//Bubblesort Button erstellen
	Button bMerg  = new Button("Mergsort");										//Mergsort Button erstellen
	Button bMin   = new Button("Minsort");										//Minsort Button erstellen
	Button zufallsButton = new Button("Zufallszahlen- und Diagrammerstellung");	//Zufallszahlen Button erstellen
	Button bAlle = new Button("Alle sortieren");								//bAlle Button erstellen

	//Label 
	Label lUeberschrift = new Label("Visualisierung von Sortierverfahren");		//Überschrift Label erstellen
	Label zufallsZ = new Label("  Hier kommmen die Zufallszahlen hin");			//Zufallszahlenpool Label erstellen
		
//-----------------------------------------------------------------------------
	//Festlegung der Abstände
	int länge = 700/7;							 //Abstand zur Seite
	int höhe = 700/7;							 //Abstand zur Decke
		
	//Festlegung der Höhe und Breite der Buttons 
	int bhoe = 20;								 //Höhe der Buttons
	int bbrei = 100;							 //Breite der Buttons
	
	//Festlegung von Sonstigem
	public int x[]= new int[500];				 //Variable für Random    
	
//-----------------------------------------------------------------------------
	//Schriftarteinstellung
	Font lUeberschriftfont = new Font("Serif", Font.BOLD, 28);		 //Überschrift Schriftart
	Font bQBMM = new Font("Dialog", Font.BOLD, 12);					 //Quicksort etc Schriftart
	Font zufallB = new Font("DialogInput", Font.BOLD, 12);			 //Zufallszahlenlabel Schriftart
	
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
	//Hauptmethode	
	public static void main(String arg[])			
	{
		new VisualisierungVonSortierverfahren();								
	}
	
	public VisualisierungVonSortierverfahren() 												//Konstruktor der Klasse
	{
		//Form Initialisieren
		super("VisuSort");						 //Fenstername
    	setSize(700,700);						 //Fenstergröße
    	setLocation(150,25);					 //"Startpunkt" des Programms
       	setLayout(null);						 //Layoutart
    	setVisible(true);						 //Fenster sichtbar machen
    	setResizable(false);					 //Fenstergröße kann nicht verändert werden!!!
		addWindowListener(new WindowAdapter() 					
      		{													
         	public void windowClosing(WindowEvent event)					//Window
         	{																//Closing
            System.exit(0);													//Adapter
         	}
      	});
      	
      	
      		//Labels bounden
       	lUeberschrift.setBounds(länge+20,höhe/4,500,60);			 //Überschrift Label bounden
       	zufallsZ.setBounds(länge/5,höhe+560,600,40);				 //Zufallszahlen Label bounden
    	
    	//Bounden der Buttons
    	bQuick.setBounds(länge/4,höhe+200,bbrei,bhoe);				 //Quicksort Button bounden
       	bBubble.setBounds(länge+475,höhe+200,bbrei,bhoe);			 //Bubblesort Button bounden
       	bMerg.setBounds(länge/4,höhe+500,bbrei,bhoe);				 //Mergsort Button bounden
       	bMin.setBounds(länge+475,höhe+500,bbrei,bhoe);				 //Minsort Button bounden
       	zufallsButton.setBounds(länge/4,höhe+535,bbrei+165,bhoe);	 //Zufallszahlen Button bounden
       	bAlle.setBounds(länge/4*12,höhe+240,bbrei,bhoe);			 //Alle_sortieren Button bounden
       	
//-----------------------------------------------------------------------------
       	//Schriftartverteilung
       	lUeberschrift.setFont(lUeberschriftfont);	  //Überschrift Schirftart
       	zufallsZ.setFont(zufallB);					  //Zufallszahlenpool Schriftart
       	
       	bQuick.setFont(bQBMM);						  //Den Buttons
       	bBubble.setFont(bQBMM);						  //Die Schriftarten
       	bMerg.setFont(bQBMM);						  //zuweisen
       	bMin.setFont(bQBMM);						  //
       	zufallsButton.setFont(bQBMM);				  //
       	bAlle.setFont(bQBMM);						  //
       	
//-----------------------------------------------------------------------------
       	//Alles einfügen
       	add(bQuick); 								  //Quicksort Button einfügen
       	add(bBubble); 								  //Bubblesort Button einfügen
       	add(bMerg); 								  //Mergsort Button einfügen
       	add(bMin);		 							  //Minsort Button einfügen
       	add(zufallsButton);							  //Zufallszahlen Button einfügen
       	add(bAlle);									  //Alle_sortieren Button einfügen
      
     	add(lUeberschrift);							  //Überschrift Label einfügen
     	add(zufallsZ);								  //Zufallszahlen Label einfügen
     	
    	zufallsButton.addActionListener(new ZufallsButtonListener());  	//ActionListener für ZufallsButton*/
     	bQuick.addActionListener(new BQuickButtonListener());
   
//---------------------------------------Sortierverfahren und Diagramm-----------------------------------------------//
    		
		//Zufällige Zahlen speichern
		x= new int[15];										//Array von 15 Zahlen
		for(int i=0; i<15; i++)										//for-Schleife für die 15Random Zahlen
		
		x[i] = (int)Math.round(Math.random() * 20);			//erstellt für das Array zahlen Zufahlszahlen die in den Index [i] 
										
		//Zeichnen
		//show();
		//setVisible(true);
		
}
	//Buttoneinstellungen für das Sortieren.
	//Dem Button SortierButton wird ein Actionlistener hinzugefügt 
		class ZufallsButtonListener implements ActionListener				//Klasse Deklarieren 
    {
       public void actionPerformed(ActionEvent e)
       { 	
 	      Graphics g = getGraphics();			 //Nötig, damit durch den Button gezeichnet wird
    	  String abc ="";                        //Erzeugt das Arry abc
 	      for (int i=0; i<15; i++) {            //Forschleife für die Anzahl der Zufallszahlen
 	      x[i] = (int)(Math.random() * 100+1);	 //Speichert die Zufallszahlen in x[i]
 	      System.out.println(x[i]);              //Ausgabe der Zufallszahlen in der Konsole
   	      abc += " | " + x[i];                   //Hängt die Werte von x an tmp dran
 		}
 		zufallsZ.setText(abc);										//Gibt den String "tmp" in Label aus 
       
       			
		//Zahlen zeichnen
		g.setColor(Color.white);									//Setzt den Background auf "white"
		g.fillRect(0, 0,350, 350);					//Zeichnet das Diagramm
		g.setColor(Color.black);			//Darunter liegende zu zeichnende Objekte werden schwarz
		g.drawLine(350,0,350,700);			//Vertikale Linie
		g.drawLine(0,350,700,350);			//Horizontale Linie
		
		int balkenAbstand1 = 15;			//Festlegung des Abstandes zwischen den Diagrammbalken
		int height1 =20;					//Höhenfaktor für die Balken
		int xPosStart1 = 15;				//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart1 =290;				//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		/*int width  = (int)(getWidth() / 40);						//Breite 
		int left   = 0;								
		int top    = getHeight() - 50;								//Höhster Balken
		int height = (int)((getHeight() - 70) / 30);				//Höhe*/
		
		g.setColor(Color.red);				//Darunter liegende zu zeichnende Objekte werden rot
		for(int i=0; i<15; i++)
		{
		xPosStart1 += balkenAbstand1;	//Abstand der Balken
		g.fill3DRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 10, height1 * x[i]/10, true);	
		}
		
		/*g.setColor(Color.red);										//Setzt die Balkenfarbe auf ROT
		for(int i=0; i<15; i++)										//
		{
			left += width;
			g.fill3DRect(left, top - height * x[i]/10, 10, height * x[i]/10, true);	//Füllt die Balken in ROT mit den davor generierten Werten.
		}*/
	
       
       }
    }
    
	class BQuickButtonListener implements ActionListener 
	 {
    
   		public void actionPerformed(ActionEvent e)
   		{
    	 	quickSort(x);
   		}
    
 	} 
	
	/**/
	
	private void meineswapDraw(int[] Array, int swap1, int swap2, int pivot, int leftBorder, int rightBorder)
	{
		meineswap(Array, swap1, swap2);
		
		// Animiert zeichnen, dabei Buffer verwenden
		//BufferedImage newGraph = ((Graphics2D)getGraphics()).getDeviceConfiguration().createCompatibleImage(
		//getWidth(), getHeight());
		Graphics g = /*newGraph.*/getGraphics();
		g.setColor(Color.white);
		g.fillRect(0, 0, getWidth(), getHeight());
		
		int balkenAbstand1 = 15;		//Festlegung des Abstandes zwischen den Diagrammbalken
		int height1 =20;				//Höhenfaktor für die Balken
		int xPosStart1 = 15;			//Anfang auf der X-Achse des Ersten Diagrammbalkens
		int yPosStart1 =290;			//Anfang auf der Y-Achse des Ersten Diagrammbalkens
		
		
		for(int i=0; i<15; i++)
		{
			if(i != pivot)
				g.setColor(Color.red);
			else
				g.setColor(Color.green);
			if(i == swap1 || i == swap2)
				g.setColor(g.getColor().brighter().brighter().brighter());
			
			xPosStart1 += balkenAbstand1;
			g.fill3DRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 10, height1 * x[i]/10, true);
			
			g.setColor(Color.black);
			
			if(i == leftBorder)
				g.fillRect(xPosStart1, yPosStart1 - height1 * x[i]/10, 3, height1 * x[i]/10);
			else if(i == rightBorder)
				g.fillRect(xPosStart1 + 10 - 3, yPosStart1 - height1 * x[i]/10, 3, height1 * x[i]/10);
		}
		
		//getGraphics().drawImage(newGraph, 0, 0, this);
		
		try { Thread.sleep(300); } catch(Exception e) { }
	}
	
	// Wichtige Funktionen für Quicksort 
	private void meineswap(int[] Array, int i, int j)
	{
		int tmp = Array[i];
		Array[i] = Array[j];
		Array[j] = tmp;
	}
	
	// Ab hier das eigentliche Quicksort 
	//**** Quicksort-Algorithmus ****
	public void quickSort(int[] Array)
	{
		quickSort(Array, 0, Array.length - 1);
	}
	
	private void quickSort(int[] Array, int left, int right)
	{
		if(right > left)
		{
			int index = left + (int)((right - left) / 2);
			int pivot = Array[index];	//Pivot = ein Element nehmen
			
			//swap(Array, index, rechts)
			meineswapDraw(Array, index, right, index, left, right);
			index = left;
			for(int i = index; i < right; ++i)
			{
				if(Array[i] < pivot)
					//swap(Array, index++, i)
					meineswapDraw(Array, index++, i, index, left, right);
			}
			//swap(Array, index, rechts)
			meineswapDraw(Array, index, right, index, left, right);
			
			quickSort(Array, left, index);
			quickSort(Array, index + 1, right);
		}
	}
	
//---------------------------------------------------------------------------------------------//		
	//Buttoneinstellungen für 
	//Zufallszahlengenerierung im Label zufallsZ

}
```


----------



## keksmafia (15. Apr 2008)

nur das es langsamer sein sollte.......

is langsamer.....


----------



## qlimax (15. Apr 2008)

endlich weiter gekommen .... so macht das doch spass xD


----------



## keksmafia (16. Apr 2008)

jo jetzt nur noch in 2 tagen  3 anderen  sortverfahren -.-


----------



## qlimax (16. Apr 2008)

jooo das wird lustig alle male  

aber das schaffen wir schon wenn man überlegt das er heute Nachmittag noch nix gemacht hat


----------



## Marco13 (16. Apr 2008)

Wenn es Spaß macht, schön. Ein bißchen dämpfen muss ich das aber, indem ich sage, dass Aufwand, dort weitere Soriterverfahren einzubauen, _vergleichsweise_ hoch ist, und dass es, wenn man getGraphics() auf einer Component aufruft, jederzeit und unerwartet mit einer NullPointerException krachen kann. Aber ... "wenn's läuft is' ja gut" :wink:


----------



## qlimax (16. Apr 2008)

hehe :> ja das wird bestimmt lustig neue Sortierverfahren da rein zu bauen aber das wird auch noch^^


----------



## Gast (5. Mai 2008)

achja

habs gelöst....
werd hier aber genau so wenig ne lösung posten wie jeder andere 

thx für nix und bye bye


----------



## Marco13 (5. Mai 2008)

Auch genauso viel? Hatte das aus Langeweile mal gemacht. Die Sortieralgorithmen werden in der Methode "initAlgorithms" hinzugefügt (mit jeweils EINER Zeile). Es können dort Objekte beliebiger Klassen übergeben werden, die "SortAlgorithm" extenden. Wenn man die sortAlgorithm#swap Methode aufruft, wird neu gezeichnet (d.h. es werden "alle Vertauschungsoperationen" angezeigt.

Bitte für nichts, und auch bye bye


```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.util.List;
import java.util.ArrayList;

public class SortAlgorithms extends JFrame
{
    public static void main(String[] args)
    {
        new SortAlgorithms();
    }

    private JPanel sortPanelContainer;
    private List<SortAlgorithm> sortAlgorithms = new ArrayList<SortAlgorithm>();

    public SortAlgorithms()
    {
        super("SortAlgorithms");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new BorderLayout());

        add(new Label("Sort algorithms", Label.CENTER), BorderLayout.NORTH);
        sortPanelContainer = new JPanel(new GridLayout(1,0));
        add(sortPanelContainer, BorderLayout.CENTER);
        add(createControlPanel(), BorderLayout.SOUTH);

        initAlgorithms();
        pack();
        setVisible(true);
    }

    private JPanel createControlPanel()
    {
        JPanel panel = new JPanel(new FlowLayout());

        JButton startButton = new JButton("Start");
        startButton.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                execute();
            }
        });
        panel.add(startButton);

        JButton resetButton = new JButton("Reset");
        resetButton.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                initAlgorithms();
            }
        });
        panel.add(resetButton);

        return panel;

    }

    private void initAlgorithms()
    {
        sortPanelContainer.removeAll();
        sortAlgorithms.clear();
        addSortAlgorithm(new BubbleSort());
        addSortAlgorithm(new QuickSort());
        addSortAlgorithm(new SelectionSort());
        validate();
    }

    private void addSortAlgorithm(SortAlgorithm sortAlgorithm)
    {
        sortAlgorithms.add(sortAlgorithm);
        sortAlgorithm.setArray(createRandomArray(50, 100));

        SortPanel sortPanel = new SortPanel();
        sortPanel.setSortAlgorithm(sortAlgorithm);
        sortAlgorithm.addObserver(sortPanel);

        JPanel panel = new JPanel(new BorderLayout());
        panel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        panel.add(sortPanel, BorderLayout.CENTER);
        panel.add(new JLabel(sortAlgorithm.getClass().getName()), BorderLayout.SOUTH);
        sortPanelContainer.add(panel);
    }

    private int[] createRandomArray(int size, int maxElement)
    {
        int result[] = new int[size];
        for (int i=0; i<size; i++)
        {
            result[i] = (int)(Math.random() * maxElement);
        }
        return result;
    }


   public void execute()
   {
       for (int i=0; i<sortAlgorithms.size(); i++)
       {
           final SortAlgorithm sortAlgorithm = sortAlgorithms.get(i);
           Thread thread = new Thread(new Runnable()
           {
               public void run()
               {
                   sortAlgorithm.sort();
               }
           });
           thread.start();
       }
   }
}


abstract class SortAlgorithm extends Observable
{
    protected int array[];

    public void setArray(int array[])
    {
        this.array = array;
        setChanged();
        notifyObservers();
    }

    public int getArrayLength()
    {
        if (array == null)
        {
            return -1;
        }
        return array.length;
    }

    public int getArrayElement(int index)
    {
        return array[index];
    }

    public abstract void sort();

    protected void swap(int i, int j)
    {
       int temp = array[i];
       array[i] = array[j];
       array[j] = temp;
       doNotifyObservers();
    }

    protected void doNotifyObservers()
    {
        setChanged();
        notifyObservers();
        try
        {
            Thread.sleep(20);
        }
        catch (InterruptedException e)
        {
        }
    }
}


class SortPanel extends JPanel implements Observer
{
    private SortAlgorithm sortAlgorithm;
    private int maxElement = -Integer.MAX_VALUE;

    public void setSortAlgorithm(SortAlgorithm sortAlgorithm)
    {
        this.sortAlgorithm = sortAlgorithm;
        setPreferredSize(new Dimension(200,200));
        computeMaxElement();
    }

    private void computeMaxElement()
    {
        maxElement = -Integer.MAX_VALUE;
        for (int i=0; i<sortAlgorithm.getArrayLength(); i++)
        {
            int arrayElement = sortAlgorithm.getArrayElement(i);
            maxElement = Math.max(arrayElement, maxElement);
        }
    }

    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        int n = sortAlgorithm.getArrayLength();
        int barWidth = getWidth() / n - 1;
        float heightScale = (float)getHeight() / maxElement ;
        g.setColor(Color.BLACK);
        for (int i=0; i<n; i++)
        {
            int height = (int)(sortAlgorithm.getArrayElement(i) * heightScale);
            g.fillRect(i * (barWidth + 1), getHeight()-height, barWidth, getHeight());
            //System.out.println("paint "+barWidth+" "+height+" "+getBounds()+" max "+maxElement+" scale "+heightScale);
        }
    }

    public void update(Observable o, Object arg)
    {
        if (maxElement == -Integer.MAX_VALUE)
        {
            computeMaxElement();
        }
        repaint();
    }

}



class SelectionSort extends SortAlgorithm
{
    public void sort()
    {
        for (int i = 0; i< array.length - 1; i++)
        {
            int min = i;
            for (int j=i+1; j<array.length; j++)
            {
                if (array[j] < array[min])
                {
                    min = j;
                }
            }
            swap(i, min);
        }
    }
}


class QuickSort extends SortAlgorithm
{
    public void sort()
    {
        quickSort(0, array.length-1);
    }

    private void quickSort(int lo0, int hi0)
    {
        int lo = lo0;
        int hi = hi0;
        int mid;
        if (hi0 > lo0)
        {
            mid = array[(lo0 + hi0) / 2];
            while (lo <= hi)
            {
                while ((lo < hi0) && (array[lo] < mid))
                    ++lo;
                while ((hi > lo0) && (array[hi] > mid))
                    --hi;

                if (lo <= hi)
                {
                    swap(lo, hi);
                    ++lo;
                    --hi;
                }
            }
            if (lo0 < hi)
                quickSort(lo0, hi);
            if (lo < hi0)
                quickSort(lo, hi0);
        }
    }
}



class BubbleSort extends SortAlgorithm
{
    public void sort()
    {
        boolean swapped = true;
        do
        {
            swapped = false;
            for (int i=0; i<array.length-1; i++)
            {
                if (array[i] > array[i+1])
                {
                    swap(i, i+1);
                    swapped = true;
                }
            }
        }while (swapped);
    }
}
```


----------

