ComputerBase Menü
Aktuelles

Java Umprogrammierung von Insertionsort zu Mergesort

Status
Für weitere Antworten geschlossen.
L

Limette24

Cadet 1st Year
Registriert
März 2013
Beiträge
11
Hallo Leute,

ich bin momentan in der Jahrgangsstufe 11 auf dem Gymnasium und mache nächstes Jahr mein Abitur.
Ich habe Informatik als schriftliches Abiturfach belegt und muss jetzt einen Mergesort schreiben.
Ich habe bereits das komplette Programm geschrieben und in der Schule habe ich mit einem Kollegen zusammen den Insertionsort geschrieben.

Mein Problem ist jetzt, dass ich überhaupt keine Ahnung habe, wo ich anfangen soll.
Wir benutzen BlueJ, um diese Dinge zu programmieren.

Ist jemand so lieb, mir den Insertionsort in einen Mergesort umzuschreiben? Ich weiß nicht, ob man sich hier im Forum so sehr gegenseitig hilft, aber zur Not würde ich auch ein paar Taler springen lassen!

Es ist wirklich total dringend!

Es muss also nur der Teil "insertionsort" umgeschrieben werden (letzter Teil).

Hier der Programmcode:

Code: 
/**
 * Die Klasse Vokabeldatenbank wurde automatisch erstellt: 
 * 
 * @author 
 * @version 12.11.2012
 */

import sum.komponenten.*;
import sum.werkzeuge.*;
import sum.ereignis.*;

public class Vokabeldatenbank extends EBAnwendung
{
    // Objekte
    private Etikett hatEtikettDeutsch;
    private Etikett hatEtikettEnglisch;
    private Etikett hatEtikettStatus;
    private Textfeld hatTextfeldDeutsch;
    private Textfeld hatTextfeldEnglisch;
    private Knopf hatKnopfEnglischesWortNachschlagen;
    private Knopf hatKnopfDeutschesWortNachschlagen;
    private Knopf hatKnopfAufnehmen;
    private Knopf hatKnopfEntfernen;
    private Knopf hatKnopfAnfang;
    private Knopf hatKnopfWeiter;
    private Knopf hatKnopfEnde;
    private Knopf hatKnopfSortieren;

    private List hatVokabelliste;
    // Attribute

    /**
     * Konstruktor
     */
    public Vokabeldatenbank()
    {
        //Initialisierung der Oberklasse
        super(631, 155);

        hatEtikettDeutsch = new Etikett(30, 30, 75, 25, "Deutsch:");
        // Ausrichtung
        hatEtikettDeutsch.setzeAusrichtung(Ausrichtung.LINKS);
        hatEtikettEnglisch = new Etikett(30, 60, 75, 25, "Englisch:");
        // Ausrichtung
        hatEtikettEnglisch.setzeAusrichtung(Ausrichtung.LINKS);
        hatEtikettStatus = new Etikett(30, 90, 200, 25, "");
        // Ausrichtung
        hatEtikettStatus.setzeAusrichtung(Ausrichtung.LINKS);
        hatTextfeldDeutsch = new Textfeld(110, 30, 300, 25, "");
        // Ausrichtung
        hatTextfeldDeutsch.setzeAusrichtung(Ausrichtung.LINKS);
        hatTextfeldEnglisch = new Textfeld(110, 60, 300, 25, "");
        // Ausrichtung
        hatTextfeldEnglisch.setzeAusrichtung(Ausrichtung.LINKS);
        hatKnopfEnglischesWortNachschlagen = new Knopf(420, 30, 200, 25, "Englisches Wort nachschlagen");
        hatKnopfEnglischesWortNachschlagen.setzeBearbeiterGeklickt("hatKnopfEnglischesWortNachschlagenGeklickt");
        hatKnopfDeutschesWortNachschlagen = new Knopf(420, 60, 200, 25, "Deutsches Wort nachschlagen");
        hatKnopfDeutschesWortNachschlagen.setzeBearbeiterGeklickt("hatKnopfDeutschesWortNachschlagenGeklickt");
        hatKnopfAufnehmen = new Knopf(200, 90, 100, 25, "Aufnehmen");
        hatKnopfAufnehmen.setzeBearbeiterGeklickt("hatKnopfAufnehmenGeklickt");
        hatKnopfEntfernen = new Knopf(310, 90, 100, 25, "Entfernen");
        hatKnopfEntfernen.setzeBearbeiterGeklickt("hatKnopfEntfernenGeklickt");
        hatKnopfAnfang = new Knopf(30, 120, 100, 25, "Anfang");
        hatKnopfAnfang.setzeBearbeiterGeklickt("hatKnopfAnfangGeklickt");
        hatKnopfWeiter = new Knopf(136, 120, 100, 25, "Weiter");
        hatKnopfWeiter.setzeBearbeiterGeklickt("hatKnopfWeiterGeklickt");
        hatKnopfEnde = new Knopf(240, 120, 100, 25, "Ende");
        hatKnopfEnde.setzeBearbeiterGeklickt("hatKnopfEndeGeklickt");
        hatKnopfSortieren = new Knopf(420, 120, 100, 25, "Sortieren");
        hatKnopfSortieren.setzeBearbeiterGeklickt("hatKnopfSortierenGeklickt");

        hatVokabelliste = new List();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfEnglischesWortNachschlagen fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfEnglischesWortNachschlagenGeklickt()
    {
        Vokabel lZuPruefendeVokabel;
        boolean lGefunden;

        lGefunden = false;
        this.hatVokabelliste.toFirst();

        while (!lGefunden && this.hatVokabelliste.hasAccess())
        {
            lZuPruefendeVokabel = (Vokabel)this.hatVokabelliste.getObject();

            if (lZuPruefendeVokabel.gibDeutschesWort().equalsIgnoreCase(this.hatTextfeldDeutsch.inhaltAlsText()))
            {
                this.zeigeAktuelleVokabel();
                lGefunden = true;
            }

            this.hatVokabelliste.next();
        }

        if (!lGefunden)
        {
            this.hatEtikettStatus.setzeInhalt("Vokabel nicht gefunden.");
        }
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfDeutschesWortNachschlagen fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfDeutschesWortNachschlagenGeklickt()
    {
        Vokabel lZuPruefendeVokabel;
        boolean lGefunden;

        lGefunden = false;
        this.hatVokabelliste.toFirst();

        while (!lGefunden && this.hatVokabelliste.hasAccess())
        {
            lZuPruefendeVokabel = (Vokabel)this.hatVokabelliste.getObject();

            if (lZuPruefendeVokabel.gibEnglischesWort().equalsIgnoreCase(this.hatTextfeldEnglisch.inhaltAlsText()))
            {
                this.zeigeAktuelleVokabel();
                lGefunden = true;
            }

            this.hatVokabelliste.next();
        }

        if (!lGefunden)
        {
            this.hatEtikettStatus.setzeInhalt("Vokabel nicht gefunden.");
        }
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfAufnehmen fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfAufnehmenGeklickt()
    {
        Vokabel lNeueVokabel;

        lNeueVokabel = new Vokabel(this.hatTextfeldDeutsch.inhaltAlsText(), this.hatTextfeldEnglisch.inhaltAlsText());
        this.hatVokabelliste.append(lNeueVokabel);

        this.hatTextfeldDeutsch.setzeInhalt("");
        this.hatTextfeldEnglisch.setzeInhalt("");
        this.hatEtikettStatus.setzeInhalt("Vokabel " + lNeueVokabel.gibDeutschesWort() + " aufgenommen.");
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfEntfernen fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfEntfernenGeklickt()
    {
        if (this.hatVokabelliste.hasAccess())
        {
            this.hatVokabelliste.remove();
        }

        this.zeigeAktuelleVokabel();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfAnfang fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfAnfangGeklickt()
    {
        this.hatVokabelliste.toFirst();
        this.zeigeAktuelleVokabel();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfWeiter fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfWeiterGeklickt()
    {
        this.hatVokabelliste.next();
        this.zeigeAktuelleVokabel();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfEnde fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfEndeGeklickt()
    {
        this.hatVokabelliste.toLast();
        this.zeigeAktuelleVokabel();
    }

    /**
     * Zeigt die Vokabel in den Textfeldern an, auf die momentan der Listenzeiger gesetzt ist.
     */
    public void zeigeAktuelleVokabel()
    {
        Vokabel lAktuelleVokabel;

        if (hatVokabelliste.hasAccess())
        {
            lAktuelleVokabel = (Vokabel)this.hatVokabelliste.getObject();
            this.hatTextfeldDeutsch.setzeInhalt(lAktuelleVokabel.gibDeutschesWort());
            this.hatTextfeldEnglisch.setzeInhalt(lAktuelleVokabel.gibEnglischesWort());            
        }
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfSortieren fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfSortierenGeklickt()
    {
        insertionSort();
        this.hatVokabelliste.toFirst();
        this.zeigeAktuelleVokabel();
    }

    /**
     * Sortiert die Vokabelliste mittels Insertion-Sort.
     */
    public void insertionSort()
    {
        List lNeueVokabelliste;
        Vokabel lAktuelleVokabel;
        
        // Neue Vokabelliste für die bereits einsortierten Vokabeln erzeugen
        lNeueVokabelliste = new List();
        
        // An den Anfang der Vokabelliste
        this.hatVokabelliste.toFirst();
        
        while (!this.hatVokabelliste.isEmpty())
        {
            // Vorderste Vokabel aus der Vokabelliste nehmen und dort entfernen; Listenzeiger verschiebt sich zum nächsten Objekt
            lAktuelleVokabel = (Vokabel)this.hatVokabelliste.getObject();
            this.hatVokabelliste.remove();
            
            // An den Anfang der sortierten Vokabelliste springen
            lNeueVokabelliste.toFirst();
            
            // Solange weiterspringen, wie die Wörter nicht mehr kürzera als das einzusortiernde Wort sind und wir uns noch in der Liste befinden
            while (lNeueVokabelliste.hasAccess() && ((Vokabel)lNeueVokabelliste.getObject()).gibDeutschesWort().length() < lAktuelleVokabel.gibDeutschesWort().length())
            {
                lNeueVokabelliste.next();
            }
            
            // Wenn wir uns noch in der Liste befinden, Vokabel vor aktuelle Position einfügen, sonst an die Liste anhängen
            if (lNeueVokabelliste.hasAccess())
            {
                lNeueVokabelliste.insert(lAktuelleVokabel);
            }
            else
            {
                lNeueVokabelliste.append(lAktuelleVokabel);
            }             
        }

        this.hatVokabelliste = lNeueVokabelliste;
    }
}

Danke im voraus!

Mit freundlichen Grüßen,
Limette24.
 
insertionsort und mergesort sind grundverschiedene algorithmen, die man nicht mal eben "ineinander umschreibt". höchstens ersetzt man das eine durch das andere.

gesuche in dieser form sind hier übrigens nicht gern gesehen, du solltest es schon selbst versuchen und bei details dann hier nachfragen.

mergesort ist übrigens im web überaus gut dokumentiert, sodass sich der aufwand für eine nachimplementierung wirklich in grenzen hält.
 
Hallo,

nun gut, aber alles, was ich ich Netz finde, ist anders geschrieben, als wir es in der Schule tun und lernen.
Und dieses "Übersetzen" bekomme ich nicht auf die Kette, ihr könnt euch nicht vorstellen, wie oft ich wieder von Vorne begonnen habe..

Beste Grüße,
Limette24.
 
dann zeig uns doch mal, was du bisher schon hast, und wo die probleme liegen.

hast du verstanden, wie mergesort funktioniert?
 
Ich habe alles wieder verworfen, weil diese 2 Zeilen einfach kein Sinn ergaben...
Und das nicht nur 2 oder 3 mal.

Also eine Liste wird in mehrer aufgeteilt, dann sortiert und hinterher wieder mit der jeweils nächsten Liste ineinander sortiert, richtig?
Aber selbst das einfache Aufteilen bekomme ich nicht hin...
 
Ich habe jetzt mal kurz deinen Code überflogen, und sehe dass es bei dir nicht darum geht, primitive Datentypen wie zB. int zu sortieren.

Um dir das ganze etwas leichter vorstellen zu können, würde ich vorschlagen, den MergeSort zuerst mit einfachen Zahlen umzusetzen.
Danach sollte es dir leichter fallen, den Sortieralgorithmus für deine Bedürfnisse zu schreiben :)
 
Zuletzt bearbeitet:
Mergesort ist ein rekursiver Algorithmus. Fang damit an die Teilung zu programmieren.
Du hast eine Liste mit n-Datensätzen. Der ganz triviale Ansatz für die Halbierung ist doch, dass du nun eine neue Liste L1 erstellst und dieser die ersten n/2-Datensätze der Ausgangsliste hinzufügst. Dann erstellst du wieder eine neue Liste L2 und fügst dieser die zweite Hälfte der Datensätze hinzu.
Nun übergibst du der Teilungsfunktion einmal die Liste L1 und einmal die Liste L2. Durch die Rekursion werden die Listen immer halbiert.
 
hast du mal versucht, um das ganze fürs erste einfacher zu machen, das sortieren einer liste von zahlen mit mergesort zu implementieren? das dürfte etwas übersichtlicher sein, danach müsstest du nur noch die zahlen durch deine objekte ersetzen und die vergleichsfunktion ersetzen.

ist zwar nicht unbedingt der sauberste weg, aber so würde ich die sache angehen.

und nochmal die frage: du verstehst (genau!), was mergesort tut?
 
Diesen MergeSort habe ich mal vor einigen Jahren aus Dokumentationszwecken implementiert.

Grundsätzlich funktioniert er so, dass ein array in kleinere Teile zerlegt wird, welche dann von einer Hilfsmethode (hier "mergeArrays") sortiert werden.

Ganz unten findest du die main-Methode, die einfach ein 1000-Zahlen Array mit Randomnumbers füllt, es dann zuerst unsortiert und dann sortiert ausgibt.

Wie du weiters sehen kannst ruft sich die Methode mergeSort() des öfteren selbst auf, was zeigt dass es sich um einen rekursiven Algorithmus handelt.

Der Code ist auch kompilierfähig also kannst du ihn jederzeit ausprobieren.

Hier eine kurze Erklärung des Ablaufes:

Code: 
funktion mergeSort(liste);
  falls (Größe von liste <= 1) dann antworte liste
  sonst
      halbiere die liste in linkeListe, rechteListe
      linkeListe = mergeSort(linkeListe)
      rechteListe = mergeSort(rechteListe)
      antworte mergeArrays(linkeListe, rechteListe)

funktion mergeArrays(linkeListe, rechteListe);
   neueListe
   solange (linkeListe und rechteListe nicht leer)
   |    falls (erstes Element der linkeListe <= erstes Element der rechteListe)
   |    dann füge erstes Element linkeListe in die neueListe hinten ein und entferne es aus linkeListe
   |    sonst füge erstes Element rechteListe in die neueListe hinten ein und entferne es aus rechteListe
   solange_ende
   solange (linkeListe nicht leer)
   |    füge erstes Element linkeListe in die neueListe hinten ein und entferne es aus linkeListe
   solange_ende
   solange (rechteListe nicht leer)
   |    füge erstes Element rechteListe in die neueListe hinten ein und entferne es aus rechteListe
   solange_ende
   antworte neueListe


Code: 
public class MergeSort {

	/**
	 * STABLE SORT ALGORITHM
	 * mergeSort algorithm that sorts an array
	 * @param array
	 * @return the sorted array
	 */
	private static int [] mergeSort(int [] array) {
		
		if(array.length <= 1) return array;
		else {
			// calculate middle, needed to seperate
			int middle = array.length / 2;
			
			// separating the originating array into two parts (left and right of the middle)
			int [] left = new int[middle]; 
			int [] right = new int[array.length - middle];

			// filling the new arrays
			for (int i = 0; i < array.length - middle; i++) 	right[i] = array[i + middle];
			for (int i = 0; i < middle; i++) 	left[i] = array[i];

			left = mergeSort(left);
			right = mergeSort(right);
			
			return mergeArrays(left, right);
		}		
	}
	
	/**
	 * takes two parts of an array and sorts its values
	 * @param left
	 * @param right
	 * @return
	 */
	private static int [] mergeArrays(int [] left, int [] right) {
		
		// create a new array that will contain the sorted values
		int [] merged = new int[left.length + right.length];
		int iL = 0, iR = 0, iN = 0; // iL = index Left -> pointer to the first not sorted element in the left array, iN = index new (index in the new array where we are currently at)
		
		while(iL < left.length && iR < right.length) {
			if(left[iL] <= right[iR]) { // insert the smaller value first (change the <= to >= in order to reverse the sort)
				
				merged[iN] = left[iL];
				iL++; iN++;	// increase the pointers
			} else {
				merged[iN] = right[iR];
				iR++; iN++; // increase the pointers
			}
		}
		
		// inserting remainig left values
		while(iL < left.length) {
			merged[iN] = left[iL];
			iL++; iN++;		
		}
		
		// inserting remaining right values
		while(iR < right.length) {
			merged[iN] = right[iR];
			iR++; iN++;
		}
		
		// return the sorted array
		return merged;
	}
	
	/**
	 * method to print an array
	 * @param array
	 */
	private static void toString(int [] array) {
		
		for(int i = 0; i < array.length; i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	
	/**
	 * main method to display the results
	 * @param args
	 */
	public static void main(String[] args) {
		
		System.out.println("MERGE SORT");
		
		// array that is mergesorted
		int [] array = new int[1000];
		
		// filling the array with randomnumbers
		for(int i = 0; i < array.length; i++) array[i] = (int) (Math.random() * array.length);
		
		System.out.println("unsorted: ");
		toString(array);
		
		// use the mergesort to sort the array
		System.out.println("sorted: ");
		toString(mergeSort(array)); // sort the array and print it		
	}
}
 
Zuletzt bearbeitet:
Moin Jungs,

ich habe nur die Vorlage verwendet, weil wir diese schon in der Schule angefangen haben und ich diese nur beendet habe.
Natürlich ginge es auch mit einfach Zahlen und das würde auch vollkommen ausreichen.

Wir haben die Sortieralgorithmen auch schon mit Feldern implementiert.
Davon habe ich auch noch den Programmcode, den ich euch nun anhänge.

Code: 
/**
 * Die Klasse Zahlensortierung sortiert ein Zahlenfeld mittels verschiedener Sortieralgorithmen.
 * 
 * @author
 * @version
 */

import sum.komponenten.*;
import sum.werkzeuge.*;
import sum.ereignis.*;

public class Zahlensortierung extends EBAnwendung
{
    // Deklaration der Objekte
    private Etikett hatEtikettFeldanzeige;
    private Knopf hatKnopfZufallszahlenGenerieren;
    private Knopf hatKnopfSortieren;
    private Rechner hatRechner;

    // Attribute
    private int[] zahlenfeld;

    /**
     * Konstruktor
     */
    public Zahlensortierung()
    {
        //Initialisierung der Oberklasse
        super(649, 108);

        hatEtikettFeldanzeige = new Etikett(40, 20, 600, 25, "");
        // Ausrichtung
        hatEtikettFeldanzeige.setzeAusrichtung(Ausrichtung.LINKS);
        hatKnopfZufallszahlenGenerieren = new Knopf(40, 50, 200, 25, "Zufallszahlen generieren");
        hatKnopfZufallszahlenGenerieren.setzeBearbeiterGeklickt("hatKnopfZufallszahlenGenerierenGeklickt");
        hatKnopfSortieren = new Knopf(245, 50, 200, 25, "Sortieren");
        hatKnopfSortieren.setzeBearbeiterGeklickt("hatKnopfSortierenGeklickt");

        hatRechner = new Rechner();
        zahlenfeld = new int[16];        
        this.hatKnopfZufallszahlenGenerierenGeklickt();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfZufallszahlenGenerieren fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfZufallszahlenGenerierenGeklickt()
    {
        for (int n = 0; n < zahlenfeld.length; n++)
        {
            zahlenfeld[n] = hatRechner.ganzeZufallsZahl(1, 99);
        }
        
        zeigeFeldinhalt();
    }

    /**
     * Vorher: Ereignis GeklicktvonhatKnopfSortieren fand statt.
     * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)
     */
    public void hatKnopfSortierenGeklickt()
    {
        insertionSort();
        zeigeFeldinhalt();
    }

    /**
     * Zeigt den aktuellen Inhalt des Feldes im Etikett an.
     */
    public void zeigeFeldinhalt()
    {
        hatEtikettFeldanzeige.setzeInhalt("");
        
        for (int n = 0; n < zahlenfeld.length; n++)
        {
            hatEtikettFeldanzeige.haengeAn(" [" + zahlenfeld[n] + "] ");
        }
    }
    
    /**
     * Sortiert das Zahlenfeld mittels BubbleSort.
     */
    public void bubbleSort()
    {
        boolean lGetauscht;
        int n, m, lTemp;
        
        lGetauscht = true;
        n = 0;
        
        while (n < zahlenfeld.length - 1 && lGetauscht)
        {
            lGetauscht = false;
            
            for (m = 0; m < zahlenfeld.length - 1 - n; m++)
            {
                if (zahlenfeld[m] > zahlenfeld[m + 1])
                {
                    lTemp = zahlenfeld[m];
                    zahlenfeld[m] = zahlenfeld[m + 1];
                    zahlenfeld[m + 1] = lTemp;
                    lGetauscht = true;
                }
            }
            
            n++;
        }
    }
    
    /**
     * Sortiert das Zahlenfeld mittels SelectionSort.
     */    
    public void selectionSort()
    {
        int n, m, lMarker, lTemp;
        
        for (n = 0; n < zahlenfeld.length - 1; n++)
        {
            lMarker = n;
            
            for (m = n + 1; m < zahlenfeld.length; m++)
            {
                if (zahlenfeld[m] < zahlenfeld[lMarker])
                {
                    lMarker = m;
                }                
            }
            
            if (lMarker != n)
            {
                lTemp = zahlenfeld[n];
                zahlenfeld[n] = zahlenfeld[lMarker];
                zahlenfeld[lMarker] = lTemp;
            }
        }   
    }
    
    /**
     * Sortiert das Zahlenfeld mittels InsertionSort.
     */
    public void insertionSort()
    {
        int n, m, lAktuelleZahl;
        
        for (n = 1; n < zahlenfeld.length; n++)
        {
            lAktuelleZahl = zahlenfeld[n];
            m = n - 1;
            
            while(m >= 0 && zahlenfeld[m] > lAktuelleZahl)
            {
                zahlenfeld[m + 1] = zahlenfeld[m];
                m--;
            }
            
            zahlenfeld[m + 1] = lAktuelleZahl;
        }
    }
    }

Edit: Wenn ich erlich bin, verstehe ich von deinem Programmcode, hubertus1990, rein gar nichts...
 
Zuletzt bearbeitet:
Doch, das verstehe ich schon.
Allerdings finde ich, dass zwischen seiner "Sprache" und die, die wir in der Schule lernen, Weeeelten liegen!
Ohje, ich sitz schon seit 14 Uhr dran und hab noch keinen Fortschritt erzielen können...

Bisher konnte ich folgendes abschreiben bzw. einfügen. Einmal ein Fehler beim return zahlenfeld (bei der if-verzweigung) und einmal weiter unten bei left = MergeSort(left);

Code: 
public void MergeSort()
    {
        if (zahlenfeld.length <= 1)
        {
            return zahlenfeld;
        }
        else
        {
            int middle = zahlenfeld.length / 2;
            int [] left = new int [middle];
            int [] right = new int [zahlenfeld.length - middle];

            for (int i = 0; i < zahlenfeld.length - middle; i++)
            {
                right[i] = zahlenfeld[i + middle];
            }

            for (int i = 0; i < middle; i++)
            {
                left [i] = zahlenfeld[i];
            }

        left = MergeSort(left);
            right = MergeSort(right);

            return mergeArrays(left,right);
        }
    }
 
Zuletzt bearbeitet:
Deine Methode MergeSort hat keinen Rückgabewert, daher die Fehler.
 
Ihr verwirrt mich..
Die Sache ist, in der Schule wird einem gesagt "So, hier habt ihr die Materialien, macht mal"..
Dann lernt man es auswendig aber versteht es nicht.

Was muss ich ändern? Helft mir! :(
 
Wenn du
public void MergeSort()
schreibst darfste kein return benutzen. void bedeutet, dass nichts zurückgegeben wird. Wenn du etwas zurückgeben willst musst du statt void den Datentyp hinschreiben
 
Wenn dir solche Grundlagen fehlen, solltest du das mit dem schriftlichen Abi in Informatik nochmal überdenken oder falls das nicht mehr änderbar ist, direkt mal die Sommerferien reservieren zum Lernen. Hast du so oft gefehlt oder wie kann das angehen?
 
Mündlich stand ich bis zum letzten Halbjahr 1+ (15 Punkte).. Dann kam ein neuer Lehrer und ich verstehe echt gar nichts mehr.
Aber wenn man dann mal jemanden drauf anspricht heißt es nur "Der Lehrer kann da nichts für" ... Jaja.
Informatik werde ich wahrscheinlich aus dem Abi rausnehmen müssen..
Aber was muss ich da nun einsetzen statt void? Int funktioniert nicht...

public int[] MergeSort()

So? :)
 
Zuletzt bearbeitet:
sorry für den wenig konstruktiven beitrag, aber so funktioniert programmieren nunmal nicht, dass man solange wahlos bekannte begriffe versucht, bis der compiler sich nicht mehr beschwert...
 
Status
Für weitere Antworten geschlossen.

Ähnliche Themen

Vulpecula
Java Sortieren durch Einfügen / InsertionSort
Antworten
8
Aufrufe
2.580
maxwell-cs
M
MR34L
Java Generic Insertionsort
Antworten
12
Aufrufe
1.869
1668mib
1
Zurück
Oben

Willkommen auf ComputerBase!

Mit Werbung weiterlesen

Besuche ComputerBase wie gewohnt mit Werbung und Tracking. Die Zustimmung ist jederzeit widerrufbar.

Details im Privacy Center und in der Liste unserer Partner. Ein Widerruf ist möglich in der Datenschutzerklärung.

… oder ComputerBase Pro bestellen

Nutze ComputerBase ohne Werbebanner, Video-Ads und Werbetracking schon für 4 €/Monat oder 36 €/Jahr.

Mehr zu ComputerBase Pro

Bereits Pro-Nutzer? Hier anmelden.

Tracking: Wir und unsere 160 Partner verarbeiten personenbezogene Daten, indem wir mit auf Ihrem Gerät gespeicherten Informationen (z. B. eindeutige Kennungen in Cookies) ein Nutzungsprofil erstellen, um z. B. Anzeigen zu personalisieren. Verarbeitungszwecke: Genaue Standortdaten und Abfrage von Geräteeigenschaften zur Identifikation, Informationen auf einem Gerät speichern und/oder abrufen, Personalisierte Anzeigen und Inhalte, Anzeigen- und Inhaltsmessungen, Erkenntnisse über Zielgruppen und Produktentwicklungen.

Impressum Kontakt Datenschutz