# Sortierverfahrensvergleich



## Frimari (5. Jun 2006)

Ich hab einen riesengroßes Problem!Ich und ein Schulkollege haben am Mittwoch Projektabgabe,hängen aber leider total fest! Die Aufgabenstellung des Projektes lautet:
---------------------------------------------------------------------------------------------------------------------------------------
Sortieverfahrensvergleich
Schreibe ein Applet zum Vergleichen und Veranschaulichen von Sortierverfahren. Es sollen immer zwei Verfahren gegenübergestellt werden. Insgesamt sind vier (zwei einfache und zwei fortgeschrittenere) Verfahren zu realisieren. Der Ablauf beim Sortieren ist grafisch zu zeigen. Es soll auch jederzeit ersichtlich sein, wie viel Speicher gerade verbraucht wird (Stack, Daten). Die sortierenden Daten sind zufällig zu erstellen.

wir haben uns für Insertion Sort, Merge Sort, Quick Sort und Selection Sort entschieden!
---------------------------------------------------------------------------------------------------------------------------------------
Ich hoffe und kann jemand bei der Lösung des Problems helfen!

Danke im Voraus

unser Code: 


```
/**
 * Titel: Klasse zum Sortieren der Daten via InsertionSort
 * @author Kopitar Florian, Friedwagner Marion
 * @version 0.1
 */
public class JInsertionSort extends JSortieren
{
    public void sort()
    {
		System.out.println("Sort in JInsertionSort");
		int v, j, i;
		int[]a=werte;


		  for (i=1; i<=a.length-1; i++)
		  {
		    v=a[i];
		    j=i-1;
		    while (j<=0 && a[j]>v);
		    {
			  a[j+1]=a[j];
		      j=j-1;
		      repaint();
		    }

		    a[j+1]=v;
   }

    	// Code
    	// bei jeder Aenderung repaint
    }
}

/**
 * Titel: Klasse zum Sortieren der Daten via SelectionSort
 * @author Kopitar Florian, Friedwagner Marion
 * @version 0.1
 */
public class JSelectionSort extends JSortieren
{
    public void sort()
    {
	//int i, minIndex, tausch;

	//for (i=0; i<=werte.length-2; i++)
	//{
		//minIndex=sucheMin(werte, i);
  		//tausch=werte[minIndex]=werte[i];
  		//werte[i]=tausch;
 	//}
 }
}

	// int[]werte .. fehler ??

	//public int sucheMin (int[] werte, int startIndex)
	//{
	//	int i, min, minIndex;

  	//	min=werte [startIndex];
    	//	or (i=startIndex+1; i<=werte.length-1; i++)
    //  		if (werte[i] < min)
   //   		{
	//	min=werte[i];
  //     		minIndex=i;
   //   		}
  //    		return minIndex;
  	//}
//}


import java.awt.*;
import java.applet.*;
import javax.swing.*;
import java.util.Random;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * Titel: Applet zum Vergeleichen von Sortierverfahren, Schieberegler
 * @author Kopitar Florian, Friedwagner Marion
 * @version 0.3
 * @laseChange	 28.05.06 14:35
 */

 public class JSortApplet extends JApplet implements ActionListener
 {
	// Buttons
 	private JToggleButton quickSort;
	private JToggleButton mergeSort;
	private JToggleButton insertionSort;
	private JToggleButton selectionSort;
	private JButton start;
  	private JButton reset;

  	//private JLabel name; WIRD NICHT BENÖTIG
	private int j=0;

 	// die eigentliche Zeichenfläche
 	private JQuickSort sort1;
 	private JMergeSort sort2;
 	private JInsertionSort sort3;
 	private JSelectionSort sort4;

	// wird für actionPerformed benötigt
	private JPanel hilf;

 	// Construct the applet
 	public void Applet () {}

 	// Init
 	public void init()
 	{

 		quickSort = new JToggleButton("Quick Sort");
		mergeSort = new JToggleButton("Merge Sort");
		selectionSort = new JToggleButton("Selection Sort");
		insertionSort = new JToggleButton("Insertion Sort");
		reset = new JButton("CLEAR");
        start = new JButton("START");
        start.setEnabled(false);
        //name = new JLabel("SortierVerfahrensVergleich",JLabel.CENTER); // nicht eingebunden

        Container c = this.getContentPane();
        c.setLayout(new BorderLayout());

        JPanel layout=new JPanel();
        layout.setLayout(new GridLayout(2,3));
        c.add(layout,BorderLayout.NORTH);
        // Buttons zu GridLayout zusammenfassen
        layout.add(quickSort);
        layout.add(mergeSort);
        layout.add(selectionSort);
        layout.add(insertionSort);
        layout.add(reset);
        layout.add(start);


 		//Sortier Objekt erzeugen
 		sort1 = new JQuickSort();
 		sort2 = new JMergeSort();
 		sort3 = new JInsertionSort();
 		sort4 = new JSelectionSort();

 		hilf = new JPanel();
 		hilf.setLayout(new GridLayout(2,1));
 		c.add(hilf,BorderLayout.CENTER);

        quickSort.addActionListener(this);
        mergeSort.addActionListener(this);
        selectionSort.addActionListener(this);
        insertionSort.addActionListener(this);
        reset.addActionListener(this);
        start.addActionListener(this);

	}// Init


 	public void start () {}

 	public void stop () {}

 /*
  * actionPerformed Methode: sind 2 SortButton gedrückt werden die anderen beiden SortButtong inaktiv
  * Start Button wird erst aktiv wenn 2 Sortierverfahren ausgewählt sind
  * Reset Button setzt alles auf den Ursprung zurück
  */

 	public void actionPerformed(ActionEvent e)
	{
		// Action Listener für Quick Sort
		if(e.getSource() == quickSort)
		{
			if(j<2)
				hilf.add(sort1);

			if(quickSort.isSelected())
				j++;
				buttonSetzen(j);
		}

		// Action Listener für Merge Sort
		if(e.getSource() == mergeSort)
		{
			if(j<2)
				hilf.add(sort2);

			if(mergeSort.isSelected())
				j++;
				buttonSetzen(j);
		}

		// Action Listener für Insertion Sort
		if(e.getSource() == insertionSort)
		{
			if(j<2)
				hilf.add(sort3);

			if(insertionSort.isSelected())
				j++;
				buttonSetzen(j);
		}

		// Action Listener für Selection Sort
		if(e.getSource() == selectionSort)
		{
			if(j<2)
				hilf.add(sort4);

			if(selectionSort.isSelected())
				j++;
				buttonSetzen(j);
		}

		// Action Listener für Reset Taste
		if(e.getSource() == reset)
		{
			// Zurücksetzen der Hilfsvariable
			j=0;
			// Buttons wieder auf Aktivsetzen
			quickSort.setEnabled(true);
			mergeSort.setEnabled(true);
			insertionSort.setEnabled(true);
			selectionSort.setEnabled(true);
			quickSort.setSelected(false);
			mergeSort.setSelected(false);
			insertionSort.setSelected(false);
		 	selectionSort.setSelected(false);
		 	start.setEnabled(false);

		 	// Schauen welche Componenten ( sortierverfahren ) im hilf Layout hängen diese lösen + stopen
	 		Component[] comps=hilf.getComponents();
	 		for (int x=0;x<comps.length;x++)
	 		{
	 			JSortieren sort=(JSortieren)comps[x];
	 			sort.stop();
	 		}
		 	// Panels vom GridLayout (hilf) lösen
		 	hilf.removeAll();
	 	}

	 	// Action Listener für Start Taste
	 	if(e.getSource() == start )
	 	{
			start.setSelected(false);
	 		Component[] comps=hilf.getComponents();

	 		for (int x=0; x<comps.length; x++)
	 		{
	 			JSortieren sort=(JSortieren)comps[x];
	 			// Übergeben des RandomArrays
	 			sort.setWerte(zufallsZahlen(calcAnzahlStriche(hilf.getWidth()),calcHöheStriche(hilf.getHeight())));
	 			// Setzen der Hoehe für Darstellung der Striche
	 			sort.setHoehe(hilf.getHeight()/2);
	 			// run
	 			sort.run();

	 		}
		}// start Taste

		validate();
		repaint();
	}// actionPerformed


 /*
  * Methode zum erkenn ob schon 2 SortButton ausgewählt wurden wenn ja,
  * deaktieviern der 2 anderen SortButton
  */

	public void buttonSetzen(int x)
	{
		if(x>=2)
		{
		 	quickSort.setEnabled(false);
		 	mergeSort.setEnabled(false);
		 	insertionSort.setEnabled(false);
		 	selectionSort.setEnabled(false);
		 	start.setEnabled(true);
	 	}
	}// buttonSetzen

 /*
  * Berechnet durch die Breite des Applets unter abzug von -10-10 Pixel für den Rand die anzahl der Striche
  */

	public int calcAnzahlStriche(int a)		// a..Breite
	{
		// -10 -10 für Rand links und rechts durch 8 wegen 4 Pixel pro strich 4 Pixel pro Zwischenraum
		return ((a-10-10)/8);
	}

 /*
  * Berechnet durch die Höhe des Applets die maximale Höhe für die Striche (Rechtecke)
  * Die Höhe ergibt sich durch die Hälfte der höhe vom GridLayout hilf - Ränder
  */

	public int calcHöheStriche(int b)	// b..Höhe
	{
		// - 30 Rand Oben für Beschriftung Stacktiefe und Speicheraufwand
		// - 5 Rand unten
		return ((b/2)-10-5);
	}

 /*
  * Es müssen ZufallsZahlen mit der maximalen Höhe a erzeugt werden,
  * die größe des Arrays hängt von der Breite des Applets zusammen
  */

	public int[] zufallsZahlen(int a,int b) // a anzahl der striche, b höhe der striche
	{
		System.out.println("zufallsZahlen "+a+" "+b);
		int i;
		int []h = new int [a];

		Random r = new Random();
		for (i=0; i<a; i++)
			h[i]=(int)(r.nextDouble()*b);
        return h;

	}// Zufallszaheln
}// class

import java.awt.Graphics;
import java.util.Random;
import javax.swing.JPanel;


/**
 * Titel: Klasse zum Sortieren
 * @author Kopitar Florian, Friedwagner Marion
 * @version 0.3
 */

 public class JSortieren extends JPanel implements Runnable
 {
	// Erzeugen der Attribute der Klasse JSortieren
    private String name;
    private int hoehe;
    protected int[] werte;  // Array mit den Random Zahlen

	// Counstructor
 	public JSortieren () {}

	// die Benötigten SetMethoden
 	public void setWerte( int[] werte)
 	{
		int[] werte2 = new int[werte.length];
		for(int i=0; i<werte.length; i++)
			werte2[i]=werte[i];
	}

 	public void setName( String name)
 	{
 		this.name=name;
    }

 	public void setHoehe(int hoehe)
 	{
 		this.hoehe=hoehe;
 	}

 	public void sort()
 	{
 		// In Unterklasse Code schreiben
 	}

	public void run()
	{
		// generiere Random Array
		System.out.println("run");
		sort();
		repaint();
	}


	/*
	 * Zeichnet die Rechtecke (Striche) die Striche sind so Hoch wie der Wert in dem Array an der Stelle i,
	 * Breit sind die Striche 4 Pixel
	 */
    protected void paintComponent(Graphics g)
	{
		// Loeschen von Graphic
		// y-werte[i] bewirkt das umdrehen !!
		System.out.println("paintComponent");
		int y=hoehe-5;
 		for(int i=0; i<werte.length; i++)
 		{
 			g.fillRect(i*8,y-werte[i],4,werte[i]); // -25 damit der rand oben ist ;)

 		}
 		System.out.println("paint zeichne");
	}

	// Stop Methode um den Sortiervorgang abzubrechen
	public void stop()
	{
		Thread thisThread = Thread.currentThread();
		thisThread.interrupt();
	}

	public void init()
	{}
 }
```


----------



## unre4l (5. Jun 2006)

die komentar striche bei der ersten klasse in der sort methode gehören weg ^^


----------



## NippelGast (6. Jun 2006)

seids scho a bissal spät dran mit dem projekt. Und bei der erstbesten Forumseite die man bei Javaforum in Google findet wird der KV sicher nicht vorbeischauen...

aja...@author Kopitar Florian, Friedwagner Marion lööl^^

greez


----------



## Frimari (6. Jun 2006)

Das Problem wurde schon gelöst!!!


----------

