Bubblesort Algorithmus für Strings

Ich würde mich über hilfreiche Kommentare zur "Ansehnlichkeit" des Codes und über Verbesserungsvorschläge freuen [;

package bubblesort;

/**
*
* @version v0.2 (05/05/11)
*
*/
public class SortString
{
private int elements;
private String[] sortContent;

//Constructor
public SortString(int pElements, String[] pSortContent)
{
elements = pElements;
sortContent = new String[elements];
for(int i=0; i < elements; i++)
{
sortContent = pSortContent;
}
sortString();
}

//Sortieralgorithmus
private void sortString()
{
String temp;
boolean changed = true;
while(changed == true)
{
changed = false;
for(int i=0; i<elements; i++)
{
if(getOrder(sortContent, sortContent[i++]) == true)
{
temp = sortContent;
sortContent = sortContent[i++];
sortContent[i++] = temp;
changed = true;
}
}
}
}

private boolean getOrder(String pCurrentItem, String pNextItem)
{
if(defineOrder(pCurrentItem, 1, 1)>defineOrder(pNextItem, 1, 1))
{
return true;
}
else
{
return false;
}
}

private double defineOrder(String pItem, double pGrade, int pIndex)
{

double result = 0;
if(pItem.charAt(pIndex)=='A' || pItem.charAt(pIndex)=='a')
{
result = result+(1/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}
else if(pItem.charAt(pIndex)=='B' || pItem.charAt(pIndex)=='B')
{
result = result+(2/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}

//und so weiter

else if(pItem.charAt(pIndex)=='Z' || pItem.charAt(pIndex)=='z')
{
result = result+(26/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}
//edit v0.2
else if(pItem.charAt(pIndex)=='Ä' || pItem.charAt(pIndex)=='ä')
{
result = result+(1.5/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}else if(pItem.charAt(pIndex)=='Ö' || pItem.charAt(pIndex)=='ö')
{
result = result+(15.5/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}
else if(pItem.charAt(pIndex)=='Ü' || pItem.charAt(pIndex)=='ü')
{
result = result+(21.5/pGrade);
defineOrder(pItem, pGrade*10, pIndex++);
}
return result;
}
}
 
Zuletzt bearbeitet:

Scutus

Stammuser
Hey

Wieso übergibst du dem Konstruktor extra die Anzahl der Elemente? Du hast sie doch schon durch deinen Array vorgegeben. Dadurch ist dein Programm auch anfällig, z.B.: SortString = new SortString(100, [a, b, e, r]); <-- hier solltest du einen Fehler bekommen...
Es ist schon möglich, dass du den Array komplett durchläufst, aber warum übergibst du nicht einfach die Referenz?

Deine getOrder-Methode, bzw. defineOrder finde ich etwas redundant. Zum einen musst du bei defineOrder nicht jeden Buchstaben lower- und upper-Case aufzählen (dein 'B' ist falsch...) sondern kannst gleich alle im Array als lower-Case schreiben! Zum anderen gibt es so was wie eine ASCII-Tabelle, worin die Buchstaben nach deren Reihenfolge aufgeschrieben sind.

Dein Sortieralgorithmus scheint in Ordnung zu sein, zumindest sehe ich gerade keine groben Fehler. Aber willst du wirklich BubbleSort verwenden? :D

Hoffe, dass ich helfen konnte...

Grüße
 
Danke! Auf die Idee mit der ASCII-Tabelle bin ich leider nicht gekommen^^"
Was Bubblesort angeht: nein :D Das habe ich nur zu Übungszwecken geschrieben. Wir haben im Unterricht leider noch keine anderen Algorithmen behandelt, werden aber bald noch u.a. Quicksort besprechen.
 

purple

New member
ich finde es eingerückt schöner und übersichtlicher:
Code:
package bubblesort;0.2 (05/05/11)
*
*/
public class SortString
{
    private int elements;
    private String[] sortContent;

    //Constructor
    public SortString(int pElements, String[] pSortContent)
    {
        elements = pElements;
        sortContent = new String[elements];
        for(int i=0; i < elements; i++)
        {
            sortContent[i] = pSortContent[i];
        }
        sortString();
    }

    //Sortieralgorithmus
    private void sortString()
    {
        String temp;
        boolean changed = true;
        while(changed == true)
        {
            changed = false;
            for(int i=0; i<elements; i++)
            {
                if(getOrder(sortContent[i], sortContent[i++]) == true)
                {
                    temp = sortContent[i];
                    sortContent[i] = sortContent[i++];
                    sortContent[i++] = temp;
                    changed = true;
                }
            }
        }
    }

    private boolean getOrder(String pCurrentItem, String pNextItem)
    {
        if(defineOrder(pCurrentItem, 1, 1)>defineOrder(pNextItem, 1, 1))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    private double defineOrder(String pItem, double pGrade, int pIndex)
    {
        double result = 0;
        if(pItem.charAt(pIndex)=='A' || pItem.charAt(pIndex)=='a')
        {
            result = result+(1/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }
        else if(pItem.charAt(pIndex)=='B' || pItem.charAt(pIndex)=='B')
        {
            result = result+(2/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }

        //und so weiter

        else if(pItem.charAt(pIndex)=='Z' || pItem.charAt(pIndex)=='z')
        {
            result = result+(26/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }
        //edit v0.2
        else if(pItem.charAt(pIndex)=='Ä' || pItem.charAt(pIndex)=='ä')
        {
            result = result+(1.5/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }
        else if(pItem.charAt(pIndex)=='Ö' || pItem.charAt(pIndex)=='ö')
        {
            result = result+(15.5/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }
        else if(pItem.charAt(pIndex)=='Ü' || pItem.charAt(pIndex)=='ü')
        {
            result = result+(21.5/pGrade);
            defineOrder(pItem, pGrade*10, pIndex++);
        }
        return result;
    }
}
 
Oben