Hilfe für C



  • @DirkB Für diesen Code funktioniert die Ausgabe für jeden Durchgang

    do
        {
            swapped=false;
            for(int i=0; i<9; i++)
            {
                if(arr[i]>arr[i+1])
                {
                    int tmp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=tmp;
                    swapped = true;
                }
                j=j++;
                printf("|%d|", arr[i]);
            }
        printf("\n------------\n");
        }while(swapped==true);
    
        printf("\n");
        printf("-----------------------\n");
        printf("SortedList\n");
        for(int i=0; i<10; i=i+1)
        {
            printf("|%d|", arr[i]);
        }
    }
    

    Das ist dann das Ausgegebene Ergebnis:

    Unsorted
    |14||18||28||8||22||10||30||22||10||20|
    
    ZwischenList
    |14||18||8||22||10||28||22||10||20|
    ------------
    |14||8||18||10||22||22||10||20||28|
    ------------
    |8||14||10||18||22||10||20||22||28|
    ------------
    |8||10||14||18||10||20||22||22||28|
    ------------
    |8||10||14||10||18||20||22||22||28|
    ------------
    |8||10||10||14||18||20||22||22||28|
    ------------
    |8||10||10||14||18||20||22||22||28|
    ------------
    
    -----------------------
    SortedList
    |8||10||10||14||18||20||22||22||28||30|
    

    Ich muss jetzt nur noch schaffen das Wort Weihnachtsmann immer links von dem Unsortierten Bereich erscheint.



  • @Martin1809 sagte in Hilfe für C:

    Ich muss jetzt nur noch schaffen das Wort Weihnachtsmann immer links von dem Unsortierten Bereich erscheint.

    Wie das geht, hatte ich schon erwähnt.

    Ich hatte auch etwas zu Compilerwarnungen geschrieben.
    Wenn du die beachten würdest, käme so etwas wie j=j++ nicht durch.

    PS. deine Zwischenliste hat nur 9 Elemente.
    Man kann das lösen ohne an der Anzahl der Schleifendurchläufe etwas zu ändern.
    Es braucht nur ein printf an der richtigen Stelle.



  • @Martin1809 naja du musst dir halt eine variable erstellen, die die anzahl der bereits sortierten elemente repräsentiert. damit kannst du dir dann die anzahl der unsortierten elemente ausrechnen und sobald diese alle ausgegeben sind, rufst du printf("Weihnachtsmann"); auf.



  • @Wade1234 Wenn ich das so Versuche gibt der "Weihnachtsmann überhaupt nicht aus:

    do
        {
            swapped=false;
            for(int i=0; i<10; i++)
            {
                if(arr[i]>arr[i+1])
                {
                    int tmp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=tmp;
                    swapped = true;
                    j++;
                }
                if(i==j)
                {
                    printf("Weihnachtsmann: ");
                }
    


  • @Martin1809 naja welchen wert hat j beim eintritt in die schleife und welchen wert hat j, wenn die bedingung ausgewertet wird?



  • @Wade1234 j sollte den Wert 0 am Anfang haben und wen die Ausgewertet wird um eins höher, oder nicht?



  • @Martin1809 Das j soll die Durchläufe der do-while-Schleife zählen.

    Und sollte 0 sein, zeigt dass du es nicht weißt.
    Du musst j vor der do-while-Schleife explizit auf 0 setzen.
    Dann weißt du es sicher.



  • Ich habe j auf 0 gesetzt

    printf("\n\nZwischenList \n");
        int j=0;
        do
        {
            swapped=false;
            for(int i=0; i<10; i++)
            {
                if(arr[i]>arr[i+1])
                {
                    int tmp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=tmp;
                    swapped = true;
                    j++;
                }
                if(i==j)
                {
                    printf("Weihnachtsmann: ");
                }
                printf("|%d|", arr[i]);
            }
        }
        while(swapped==true);
    

    Dann kommt aber diese Ausgabe:

    ZwischenList
    Weihnachtsmann: |10|Weihnachtsmann: |6||30||16||20||20||16||4||4||32|
    ------------
    |6||10||16||20||20||16||4||4||30||32|
    ------------
    |6||10||16||20||16||4||4||20||30||32|
    ------------
    |6||10||16||16||4||4||20||20||30||32|
    ------------
    |6||10||16||4||4||16||20||20||30||32|
    ------------
    |6||10||4||4||16||16||20||20||30||32|
    ------------
    |6||4||4||10||16||16||20||20||30||32|
    ------------
    |4||4||6||10||16||16||20||20||30||32|
    ------------
    |4||4||6||10||16||16||20||20||30||32|
    ------------
    


  • @Martin1809 es gibt jetzt zwei Möglichkeiten:

    Du überlegst dir, wo es sinnvoll ist, das j zu erhöhen.
    (auch das habe ich schon geschrieben)

    Oder du gibst neben der Zahl noch das j mit aus (in Zeile 26)
    Dann siehst du, welche Werte j hat.



  • @Martin1809 ganz blöd gefragt: weißt du, was ein flussdiagramm ist?



  • @DirkB Wenn ich das j außerhalb der do-while schleife ausgeben ist j=20



  • @DirkB Wenn ich

    swapped=false;
    j++;
    for(...)...
    

    habe zeigt der mir

    ZwischenList
    |16|Weihnachtsmann: |18||20||18||8||12||24||26||26||32|
    ------------
    |16||18|Weihnachtsmann: |18||8||12||20||24||26||26||32|
    ------------
    |16||18||8|Weihnachtsmann: |12||18||20||24||26||26||32|
    ------------
    |16||8||12||18|Weihnachtsmann: |18||20||24||26||26||32|
    ------------
    |8||12||16||18||18|Weihnachtsmann: |20||24||26||26||32|
    ------------
    |8||12||16||18||18||20|Weihnachtsmann: |24||26||26||32|
    ------------
    6
    -----------------------
    SortedList
    |8||12||16||18||18||20||24||26||26||32|
    Process returned 0 (0x0)   execution time : 0.045 s
    

    an



  • Ist das so wie das beim Bubblesort sein sollte?
    Wenn ja habe ich das falsche Sortierprinzip benutzt.



  • @Martin1809 Geht doch.

    Hast du mal auf Wikipedia bei Bubblesort nachgeschaut?


  • Mod

    Das ist schon Bubblesort. Was du wohl nicht so ganz verstanden hast, ist, welche Teile der Liste nach dem x'ten Durchgang schon garantiert sortiert sind und welche nicht. Sortier' mal eine Liste, bei der am Anfang alles genau falsch herum sortiert ist und guck dir an, wie sich das Schritt für Schritt umordnet.



  • @SeppJ Mir ist bewusst, dass das Bubblesort ist, das Problem ist das ich die Aufgabenstellung nicht genau genug gelesen habe. Die verlangt das immer das kleinste unsortierte Element nach links gebracht wird.
    Weiß jemand wie der Algorithmus dafür heißt?



  • @Martin1809 auch bubblesort. nur mit dem unterschied, dass du da von rechts nach links tauschen musst. oder meinst du insertionsort? allgemein google -> sortieralgorithmen



  • @Wade1234 Wie mach ich das? Muss ich da einfach von

    if(arr[i]>arr[i+1])
    

    zu

    if(arr[i]<arr[i+1])
    

    ???



  • @Martin1809 also um von rechts nach links zu sortieren vergleichst du array[ARRAYSIZE - i] mit array[ARRAYSIZE - i - 1] ich bin mir aber nicht mehr sicher, ob du überhaupt noch bubblesort machen willst / sollst.



  • @Martin1809 sagte in Hilfe für C:

    Wie mach ich das? Muss ich da einfach von

    Warum probierst du das nicht aus?
    Die zweite Möglichkeit wäre, die Schleife rückwärts (von 9 nach 0) laufen zu lassen.


Anmelden zum Antworten