F
Frimari
Gast
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:
---------------------------------------------------------------------------------------------------------------------------------------
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:
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()
{}
}
