Usereingabe nach parität sortieren - Bug bei der Ausgabe

[relaxant']

Hallo,

ich habe ein Programm geschrieben, welches die Parität der eingegebenen Zahlen des Users ermittelt und sie ordnen soll. Leider hakt es bei der ermittlung des Minimumwertes(Ich wuerde es gerne in diesem im Ansatz erkennbaren Code loesen, weiß leider nur nicht, wo es da jetzt noch haengt).

Der Algorithmus soll durch eine PosOfMin() Methode aufgerufen werden (eine andere Version, welche funktionierte, nur diese mit PosOfMin() haut mir in bestimmten Situationen einige Dreher in die Ausgabe) .

Ich hoffe, ihr versteht und koennt mir sagen, wo der Bug ist. Sollte für euch denke ich nicht allzuschwer sein. Ich steh aber mittlerweile voll auf dem Schlauch und find ihn einfach nicht.

Wäre also lieb, wenn mir jemand von euch mal schnell auf die Sprünge helfen könnte!

P.S.: Nicht wundern, dass die Class in der die main-Methode ist, MasterMind 2 heißt, im selben Projekt ist naemlich noch ein kleines MasterMind auf Kommandozeilenebene, was aber einfach nicht aufgerufen wird.

public class MasterMind {
	
	//int _anzahlTips = 0;
	//int _zahlenArray[] = new int[4];
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	
//		MasterMind masterMind = new MasterMind();
//		masterMind.SpielStarten();
		ParitaetSortieren paritaetSortieren = new ParitaetSortieren();
		paritaetSortieren.EingabeUser();
		
		
	}

public class ParitaetSortieren {
	
	void EingabeUserTest() // Lediglich eine Testfunktion, mit der ich versucht habe, meinen Bug
                                //     sichtbar zu machen. Einfach ignorieren und bei EingabeUser() starten.
	{
		SortierendeZahl[] result; 
		String eingabeDesUsers[] = EinlesenUserEingabe();
		
		result = UserEingabeUmwandeln(eingabeDesUsers);
		
		
		SortierendeZahl[] zahlen = Sort2(result);
		ZahlenAusgeben(zahlen);
		System.exit(0);
	}
	
	void EingabeUser() {
	
		SortierendeZahl[] result; 
		String eingabeDesUsers[] = EinlesenUserEingabe();
				
		result = UserEingabeUmwandeln(eingabeDesUsers);	
						
		SortierendeZahl[] ungeradeSortierteZahlen = Sort2(GetGefilterteZahlen(result, false));
		SortierendeZahl[] geradeSortierteZahlen = Sort2(GetGefilterteZahlen(result, true));
		
		ZahlenAusgeben(ungeradeSortierteZahlen);
		
		System.out.println();
		
		ZahlenAusgeben(geradeSortierteZahlen);
		
		System.exit(0);
		
	}
	
	private String[] EinlesenUserEingabe() {
		
		String result[];
		
		UserHelper userHelper = new UserHelper();
		String prompt = "Zahleneingabe: ";
		String eingabeDesUsers = userHelper.getBenutzereingabe(prompt);
		
		result = eingabeDesUsers.split(" ");
		
		return result;
		
	}
	
	private SortierendeZahl[] UserEingabeUmwandeln(String[] eingabeDesUsers) {
		
		SortierendeZahl[] result = new SortierendeZahl[eingabeDesUsers.length];
		int arrayElementeAnzahl = eingabeDesUsers.length;
		
		
		for (int i = 0; i < arrayElementeAnzahl; i++)
		{
			SortierendeZahl sortierendeZahl = new SortierendeZahl();
			sortierendeZahl.setZahl(Integer.parseInt(eingabeDesUsers[i]));
			result[i] = sortierendeZahl;
				
		}
				
		return result;	
		
	}
	
	private SortierendeZahl[] GetGefilterteZahlen(SortierendeZahl[] zuFilterendeZahlen, boolean paritaet) {
		
		SortierendeZahl[] result;
		int anzahlElemente = zuFilterendeZahlen.length;
		int gezaehlteZahlen = 0;
		int arrayZaehlVariable = 0;
		
		
		for (int i = 0; i < anzahlElemente ; i++) 
		{
			
			if(paritaet == zuFilterendeZahlen[i].IsGerade()) 
			{
				gezaehlteZahlen++;
			}
			
		}
		
		result = new SortierendeZahl[gezaehlteZahlen];
		
		for (int i = 0; i < anzahlElemente ; i++)
		{
			if(paritaet == zuFilterendeZahlen[i].IsGerade())
			{
				result[arrayZaehlVariable] = zuFilterendeZahlen[i];
				arrayZaehlVariable++;
			}
		}
		return result;
		
	}
	
	SortierendeZahl[] ZahlenSortieren(SortierendeZahl[] sortierendeZahlen) {
		
		SortierendeZahl[] result = sortierendeZahlen; 
		int anzahlElemente = result.length;
		
		for( int i = 0; i < anzahlElemente; i++)
		{
			for(int j = 0; j < anzahlElemente; j++)
			{	
				if(result[i].getZahl() < result[j].getZahl())
				{
					result = Swap(result, i, j);
				}
			}	
		}

		result = sortierendeZahlen;
		return result;
	}
	
	private SortierendeZahl[] Swap(SortierendeZahl[] sortierendeZahl, int i, int j)
	{
		SortierendeZahl[] result = sortierendeZahl;
		SortierendeZahl temp;
			
		temp = result[i];
		result[i] = result[j];
		result[j] = temp;
		
		return result;
	}
	
	
	private SortierendeZahl[] Sort2(SortierendeZahl[] sortierendeZahl)
	{
		
		SortierendeZahl[] result = sortierendeZahl;
		int anzahlElemente = result.length;
		int position;
		
		for(int i = 0; i < anzahlElemente; i++)
		{
			 position = PosOfMin(sortierendeZahl, i);
			 
			 
			 if(sortierendeZahl[position].getZahl() < sortierendeZahl[i].getZahl())
			 {
				 result = Swap(result, position, i);
			 }
			 
			 
		}
		
//		result = sortierendeZahl;
		return result;
		
	}
	
	
	private int PosOfMin(SortierendeZahl[] sortierendeZahl, int startPos)
	{
		int result = 0; int posDesMinimums = 0;
		int anzahlElemente = sortierendeZahl.length;
		
		SortierendeZahl tempMin = sortierendeZahl[startPos];
		
		
		for(int i = startPos+1; i < anzahlElemente; i++)
		{
			if ( sortierendeZahl[i].getZahl() < tempMin.getZahl() )
			{
				
				tempMin = sortierendeZahl[i];				
				posDesMinimums = i;
				
				System.out.println("Ich bin die posDesMinimums :    "+posDesMinimums);
				
				result = posDesMinimums;
						
				
			}
			
			
			
		}

		return result;
		
	}
	
	private void ZahlenAusgeben(SortierendeZahl[] sortierendeZahlen){
		
		int anzahlElemente = sortierendeZahlen.length;
		
		for( int i=0; i < anzahlElemente; i++)
			{
			System.out.print(""+sortierendeZahlen[i].getZahl()+" ");
			}		
	}
}

public class SortierendeZahl {
	
	int _zahl;
	
	boolean IsGerade(){
	
		boolean result = false;
		
		if (_zahl % 2 == 0) 
		{ 
			result = true;
		}
		return result;			
	}

	public int getZahl() {
		return _zahl;
	}

	public void setZahl(int zahl) {
		_zahl = zahl;
	}

}

Und hier nur die I/O Class, hier wird der Bug definitiv nicht sein. ) Nur fürs Protokoll.

import java.io.*;


public class UserHelper 
{
	public String getBenutzereingabe(String prompt) {
		String eingabeZeile = null;
		System.out.print(prompt + "  ");
		try {
			BufferedReader is = new BufferedReader(
			new InputStreamReader(System.in));
			eingabeZeile = is.readLine();
			
			if (eingabeZeile.length() == 0 ) return null;
			
			}
		catch (IOException e) 
			{
				System.out.println("IOEception " + e);
			}
		return eingabeZeile.toLowerCase();
	}
}

Wäre euch wirklich sehr verbunden, wenn ihr mir mal sagen koenntet, wo es da haengt.

P.S.: Verzeiht mir die etwas missglückte Namensgebung an manchen Stellen was sortierendeZahl[] anbelangt.

 

[diabolik]

Der Algorithmus soll durch eine PosOfMin() Methode aufgerufen werden (eine andere Version, welche funktionierte, nur diese mit PosOfMin() haut mir in bestimmten Situationen einige Dreher in die Ausgabe) .

Kannst Du bitte jeweils ein Zahlenbeispiel für geht und geht nicht nennen? Ich würde den Bug gern reproduzieren, um nach dessen Ursache zu forschen.

 

[relaxant']

Hey,

danke für das Angebot.

Wenn Du " 5 7 1 2 6 4 " eingibst, erscheint die Ausgabe richtig, also:

7 5 1
6 4 2

absteigend geordnet. Tauschen wir aber einfach mal die 4 durch eine 8 aus in diesem Beispiel, sieht das ganze schon ganz anders aus,
siehe: Eingabe " 5 7 1 2 6 8 "

Ausgabe:

7 5 1
8 2 6

 

[diabolik]

Das Problem ist Deine Sortierfunktion. Sie durchläuft nur n Runden, wobei n die Anzahl der geraden oder ungeraden Zahlen ist. Du vergleichst immer nur mit "kleiner als", ziehst aber nicht in Betracht, dass auch ein Größer als durchaus sinnvoll sein kann. Außerdem ziehst Du keine Rekursion in Betracht, das heißt, mit einem bereits sortierten Zahlen-Array noch mal von 0 an zu sortieren. Kurz gesagt, so wie Du hier sortieren möchtest, funktioniert es nicht.

Bei Deinem fehlerhaften Beispiel passiert folgendes:

Reihenfolge: 2, 6, 8

Sort2() (Runde 1):
-> Aufruf von PosOfMin() mit startPos = 0
Ist 6 < 2? NEIN
Ist 8 < 2? NEIN
<- result = 0

Ist 2 < 2? NEIN

Sort2() (Runde 2):
-> Aufruf von PosOfMin() mit startPos = 1
Ist 8 < 6? NEIN
<- result = 0

Ist 2 < 6? JA -> SWAP

neue Reihenfolgen: 6,2,8

Sort2() (Runde 3):

-> Aufruf von PosOfMin() mit startPos = 2
Die Runde wird ausgelassen, da Du in der
for()-Schleife i=startPos+1 setzt. Du hast aber nur 3 Werte,
daher kann i niemals 3 sein.

<- result = 0

Ist 6 < 8? JA -> SWAP

neue Reihenfolgen: 8,2,6


ENDE


Jetzt müsste die Sortier-Routine eigentlich noch einmal von 0 an durchlaufen werden, bis die Sortierung stimmt. Aber wie willst Du das abfangen?


Ich habe Dir Dein Programm bezüglich der Sortierfunktion optmiert. Dabei mußte ich das Modul Sort2() komplett umbauen. Ich hoffe das ist in Deinem Interesse.

Hier das komplett funktionstüchtige Ergebnis:

package mastermind;

import java.io.*;

public class MasterMind {
    
    //int _anzahlTips = 0;
    //int _zahlenArray[] = new int[4];
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
//      MasterMind masterMind = new MasterMind();
//      masterMind.SpielStarten();
        ParitaetSortieren paritaetSortieren = new ParitaetSortieren();
        paritaetSortieren.EingabeUser();
        
        
    }
    
    
}



class ParitaetSortieren {
    
    
    void EingabeUser() {
    
        SortierendeZahl[] result; 
        String eingabeDesUsers[] = EinlesenUserEingabe();
                
        result = UserEingabeUmwandeln(eingabeDesUsers); 
        
        
        // ueberarbeitet START
        //
        SortierendeZahl[] oddNumbers = GetGefilterteZahlen(result, false);
        SortierendeZahl[] evenNumbers = GetGefilterteZahlen(result, true);
        
        SortierendeZahl[] ungeradeSortierteZahlen = Sort2(oddNumbers, 0 , oddNumbers.length-1);
        SortierendeZahl[] geradeSortierteZahlen = Sort2(evenNumbers, 0 , evenNumbers.length-1);
        //
        //ueberarbeitet ENDE
        
        
        ZahlenAusgeben(ungeradeSortierteZahlen);
        
        System.out.println();
        
        ZahlenAusgeben(geradeSortierteZahlen);
        
        System.exit(0);
        
    }
    
    private String[] EinlesenUserEingabe() {
        
        String result[];
        
        UserHelper userHelper = new UserHelper();
        String prompt = "Zahleneingabe: ";
        String eingabeDesUsers = userHelper.getBenutzereingabe(prompt);
        
        result = eingabeDesUsers.split(" ");
        
        return result;
        
    }
    
    private SortierendeZahl[] UserEingabeUmwandeln(String[] eingabeDesUsers) {
        
        SortierendeZahl[] result = new SortierendeZahl[eingabeDesUsers.length];
        int arrayElementeAnzahl = eingabeDesUsers.length;
        
        
        for (int i = 0; i < arrayElementeAnzahl; i++)
        {
            SortierendeZahl sortierendeZahl = new SortierendeZahl();
            sortierendeZahl.setZahl(Integer.parseInt(eingabeDesUsers[i]));
            result[i] = sortierendeZahl;
        }
        
        
        return result;  
        
    }
    
    private SortierendeZahl[] GetGefilterteZahlen(SortierendeZahl[] zuFilterendeZahlen, boolean paritaet) {
        
        SortierendeZahl[] result;
        int anzahlElemente = zuFilterendeZahlen.length;
        int gezaehlteZahlen = 0;
        int arrayZaehlVariable = 0;
        
        
        for (int i = 0; i < anzahlElemente ; i++) 
        {
            
            if(paritaet == zuFilterendeZahlen[i].IsGerade()) 
            {
                gezaehlteZahlen++;
            }
            
        }
        
        result = new SortierendeZahl[gezaehlteZahlen];
        
        for (int i = 0; i < anzahlElemente ; i++)
        {
            if(paritaet == zuFilterendeZahlen[i].IsGerade())
            {
                result[arrayZaehlVariable] = zuFilterendeZahlen[i];
                arrayZaehlVariable++;
            }
        }
        return result;
        
    }
    
    
    
    private SortierendeZahl[] Swap(SortierendeZahl[] sortierendeZahl, int i, int j)
    {
        SortierendeZahl[] result = sortierendeZahl;
        SortierendeZahl temp;
            
        temp = result[i];
        result[i] = result[j];
        result[j] = temp;
        
        return result;
    }
    
    
    private SortierendeZahl[] Sort2(SortierendeZahl[] sortierendeZahl, int start, int end)
    {
        // KOMPLETT UEBERARBEITET
        //
        
        SortierendeZahl[] result = sortierendeZahl;
        int i = start;
        int j = end;
        boolean sortDescending = true; // aufsteigend oder absteigend sortieren?
        
        if(j > 0){// Es müssen Werte vorhanden sein

            // mittigsten Wert als Startpunkt ermitteln
            int middle = sortierendeZahl[(i + j) / 2].getZahl();

            //  Sortieren
            while (i <= j){
                if(sortDescending == true)
                    while (getNextValue(sortierendeZahl, i)  > middle){i++;}  // solange Mittwelwert kleiner
                else
                    while (getNextValue(sortierendeZahl, i) < middle){i++;} // solange Mittwelwert groesser

                if(sortDescending == true)
                    while (getNextValue(sortierendeZahl, j)  < middle){j--;}  // solange Mittwelwert groesser

                else
                    while (getNextValue(sortierendeZahl, j)  > middle){j--;} // solange Mittwelwert kleiner

                //wenn i kleiner als j ist wird getauscht
                if (i <= j){
                    Swap(sortierendeZahl, i, j); // Integer
                    i++;
                    j--;
                }
            }
            // Rekursion
            if (start < j)
                Sort2(sortierendeZahl, start, j);
            if (i < end)
                Sort2(sortierendeZahl, i, end);

        }
        
        //      result = sortierendeZahl;
        return result;
        
    }
    
    
    // neu hinzugefuegt START
    //
    private int getNextValue(SortierendeZahl[] sortierendeZahl, int j){
         // Liefert den naechsten Wert des Arrays
        int nextEntry = 0;

        try{
            nextEntry = sortierendeZahl[j].getZahl();
        }
        catch (Exception e){
            System.out.println(e.toString());
        }
            finally
        {
        return nextEntry;
        }
    }
    //
    // neu hinzugefuegt ENDE
    
    
    
    private void ZahlenAusgeben(SortierendeZahl[] sortierendeZahlen){
        
        int anzahlElemente = sortierendeZahlen.length;
        
        for( int i=0; i < anzahlElemente; i++)
            {
            System.out.print(""+sortierendeZahlen[i].getZahl()+" ");
            }       
    }
}





class SortierendeZahl {
    
    int _zahl;
    
    boolean IsGerade(){
    
        boolean result = false;
        
        if (_zahl % 2 == 0) 
        { 
            result = true;
        }
        return result;          
    }
 
    public int getZahl() {
        return _zahl;
    }
 
    public void setZahl(int zahl) {
        _zahl = zahl;
    }
    
}   
    

 
 
class UserHelper 
{
    public String getBenutzereingabe(String prompt) {
        String eingabeZeile = null;
        System.out.print(prompt + "  ");
        try {
            BufferedReader is = new BufferedReader(
            new InputStreamReader(System.in));
            eingabeZeile = is.readLine();
            
            if (eingabeZeile.length() == 0 ) return null;
            
            }
        catch (IOException e) 
            {
                System.out.println("IOEception " + e);
            }
        return eingabeZeile.toLowerCase();
    }
}

 

[relaxant']

Super, vielen Dank für deine Mühe.

Wenn ich mir deine Erklärung durchlese, frage ich mich ernsthaft, wie ich den Baum vor lauter Wald nicht sehen konnte, aber so Phasen gibt es denke ich mal.

Und danke auch für das überarbeiten!