sorteren van een structure in C

[sadiek]

Dag programmeurs van Tweakers,
Ik heb een programma geschreven dat een array vult met een studentnummer en een cijfer voor 100 studenten met behulp van een struct en pointers.
Nu wil ik de lijst sorteren van hoge naar lage cijfers met de bubble sort algoritme met een sorteerfunctie (array_sort)

Ik weet niet precies hoe ik deze functie nou goed kan vullen. meer info staat in de code met "//"

code:

#include <stdio.h>
#include <stdlib.h>

#define KLASGROOTTE 100

//Creeer een nieuw type struct met de naam 'student'
struct student {
    int studentnummer;
    int cijfer;
};

void array_sort (struct student *klas_ptr, int array_lengte);   // prototype van de functie array_sort

int main()
{
    //Declareer een array van 100 "student" structs
    struct student klas[KLASGROOTTE];
    //Declareer een pointer naar het type struct student
    struct student *klas_ptr;
    int i, teller = 0;

    //Geef een studentnummer en cijfer aan alle 'student' structs in de array
    for (i=0; i<KLASGROOTTE; i++) {
        klas[i].studentnummer = i*10+105;
        //Geef een random cijfer tussen 0 - 99 aan elke student door rand() % 100 te nemen
        klas[i].cijfer = rand() % 100;
    }

    //Geef de pointer de waarde van het beginadres (het adres van klas[0]) van de array klas
    klas_ptr = &klas;
    //Print scores en  bereken het aantal onvoldoendes
    for (i=0; i < KLASGROOTTE; ++i) {
        //Hier gebruiken we de '->' operator om te wijzen naar het genoemde element in de struct
        printf("Student %d heeft een cijfer %d\n", klas_ptr -> studentnummer, klas_ptr -> cijfer);
        if (klas_ptr -> cijfer < 55)
            teller++;    //Incrementeren laat de pointer wijzen naar de volgende struct in de array
        klas_ptr++;
    }
    printf("\nTotaal onvoldundige cijfers = %d\n", teller);

    // hier de aanroep naar de functie om de array te sorteren op cijfer hoog naar laag
    // printen nieuwe lijst

    return 0;
}

void array_sort (struct student *klas_ptr, int array_lengte)
{
    struct student temp;
    int i;

    for(i=0; i < array_lengte; i++) {

    // hier code om de structs in de array te sorteren
    // met bubble sort algoritme, temp struct is hulp variabele bij de verwisseling
    // de twee elementen van elke struct moeten natuurlijk bijelkaar blijven

    }

}

[Onbekend]

En dit had je al gevonden?
Wikipedia: Bubblesort

Waar loop je op vast?

[sadiek]

Onbekend schreef op zaterdag 23 juni 2018 @ 18:50:
En dit had je al gevonden?
Wikipedia: Bubblesort

Waar loop je op vast?

Hoe je dit moet invullen als je pointers gebruikt, ik kan de link niet leggen

[Onbekend]

In het voorbeeld wat ik aangaf wordt verwacht dat de array alleen maar nummers heeft. Jij hebt een array van het type struct met daarin een nummer.

Dus in plaats van dit:

code:

if(klas[i-1] > klas[i])

gebruik je dit:

code:

if(klas[i-1].cijfer > klas[i].cijfer)

[sadiek]

Onbekend schreef op zaterdag 23 juni 2018 @ 19:58:
In het voorbeeld wat ik aangaf wordt verwacht dat de array alleen maar nummers heeft. Jij hebt een array van het type struct met daarin een nummer.

Dus in plaats van dit:

code:

if(klas[i-1] > klas[i])

gebruik je dit:

code:

if(klas[i-1].cijfer > klas[i].cijfer)

Als je met pointers werkt gebruik je de -> operator in plaats van de '.' operator.

Het lukt echt voor geen meter:

code:

void array_sort (struct student *klas_ptr, int array_lengte)
{
    struct student temp;
    int i;

    for(i=0; i < array_lengte; i++) {
        if((klas_ptr+i)->cijfer > (klas_ptr=i)->cijfer){

           temp = klas_ptr->cijfer;
            klas_ptr->cijfer = (klas_ptr+i)->cijfer;
            (klas_ptr+i)->cijfer = struct student temp;
        }
    }

Iemand nog een idee?

[CurlyMo]

Regel 3, 9 en 11 gaan al niet samen. Je haalt namelijk je struct (student) en je int (cijfer) door elkaar.

code:

(klas_ptr=i)->cijfer

Dit gaat natuurlijk ook nergens over. Je doet een toewijzing in een vergelijking.

Je moet echt zorgvuldiger zijn en beter debuggen. Maak zichtbaar wat er stap voor stap gebeurd in je sorteer functie. En begin gewoon eens met 3, 2, 1 en dan met 2, 3, 1 en zo steeds groter, totdat je er zeker van bent dat het werkt en je het nog met de hand kan controleren.

[ Voor 65% gewijzigd door CurlyMo op 23-06-2018 20:29 ]

[sadiek]

Geen errors meer maar hij doet nog niet wat ik wil

code:

i = 0;
    for(i=0;i<array_lengte;++i){
    printf("Student %d heeft een cijfer %d\n", (klas_ptr+i) -> studentnummer, (klas_ptr+i) -> cijfer);
 
    }
    return 0;
}
int array_lengte = 100;
void array_sort (struct student *klas_ptr, int array_lengte)
{
   
    int temp;
    int i;

    for(i=0; i < array_lengte; i++) {
        if((klas_ptr+i)->cijfer > (klas_ptr=i)->cijfer){

            temp = klas_ptr->cijfer;
            klas_ptr->cijfer = (klas_ptr+i)->cijfer;
            (klas_ptr+i)->cijfer =  temp;
        }
    }

[Feanathiel]

code:

klas_ptr->cijfer = ...

Hé, waarom pas je mijn cijfer aan? Ik had een 7

code:

(klas_ptr=i)->cijfer

Zou je kunnen uitleggen wat je hier mee probeert te doen?

code:

int temp;

In het voorbeeld stond: 'struct student temp;'. Weet je waarom 'temp' nodig is, en wat deze doet?

En:

Onbekend schreef op zaterdag 23 juni 2018 @ 18:50:
En dit had je al gevonden?
Wikipedia: Bubblesort

Waar loop je op vast?

Ik zie in het voorbeeld twee for loops staan. Zou je kunnen aangeven waarom je denkt dat je het met een enkele loop af kunt?

[CurlyMo]

sadiek schreef op zaterdag 23 juni 2018 @ 20:37:
Geen errors meer maar hij doet nog niet wat ik wil

Je doet helemaal niks met mijn opmerkingen Ook zie ik je niet debuggen. Waar zijn je printf statements om te zien wat er gebeurd in je sort?

[sadiek]

oke,
tweede for lus: check
struct student temp teruggehaald ipv temp omdat die al in het voorbeeld stond

Ik krijg nog wel errors en ik weet niet hoe ik ze moet oplossen want ik begrijp ze niet

code:

int array_lengte = 100;
    void array_sort(struct student *klas_ptr, int array_lengte);
i = 0;
    for(i=0;i<array_lengte;++i){
    printf("Student %d heeft een cijfer %d\n", (klas_ptr+i) -> studentnummer, (klas_ptr+i) -> cijfer);
    // plaats hier de aanroep naar de functie om de array te sorteren op cijfer
    // en print vervolgens de gesorteerde array opnieuw uit
    }
    return 0;
}
int array_lengte = 100;
void array_sort (struct student *klas_ptr, int array_lengte)
{
    struct student temp;
    int i,j;

    for(i=0; i < array_lengte; i++) {
        for(j=0; j< array_lengte-1; i++){
                if((klas_ptr+i)->cijfer > (klas_ptr+i)->cijfer){

                    struct student temp = klas_ptr->cijfer;
                    klas_ptr->cijfer = (klas_ptr+i)->cijfer;
                    (klas_ptr+i)->cijfer =  struct student temp;
                }
        }
    }

[ Voor 86% gewijzigd door sadiek op 23-06-2018 22:45 ]

[eric.1]

sadiek schreef op zaterdag 23 juni 2018 @ 21:27:
[...]


temp voor de tijdelijke opslag geheugen te reserveren? struct student temp kwam niet overeen met de int van cijfer. dus heb ik er een int van gemaakt. (geen idee of ik mezelf hiermee nog verder in de nesten help)

En ik weet niet waarvoor de tweede lus is. ik snap er echt niets meer van, ben er de hele dag al mee bezig en heel veel dingetjes geprobeerd maar niet het juiste.

Waarom meer dan 1 lus?
Stel je hebt;
9 8 7 6 5 4 3 2 1
Je gaat 1x door de hele lus;
8 9 7 6 5 4 3 2 1
8 7 9 6 5 4 3 2 1
.....
8 7 6 5 4 3 2 9 1
8 7 6 5 4 3 2 1 9
Dat schiet niet op toch?

[CurlyMo]

sadiek schreef op zaterdag 23 juni 2018 @ 21:27:
[...]
En ik weet niet waarvoor de tweede lus is. ik snap er echt niets meer van, ben er de hele dag al mee bezig en heel veel dingetjes geprobeerd maar niet het juiste.

Ik geef letterlijk aan waar je het fout doet. En dat doet ook je compiler (in dit geval GCC):

code:

cc -o -Wall test test.c

code:

warning: assignment makes pointer from integer without a cast [-Wint-conversion]
   if((klas_ptr+i)->cijfer > (klas_ptr=i)->cijfer) {
                                      ^
warning: operation on klas_ptr may be undefined [-Wsequence-point]
   if((klas_ptr+i)->cijfer > (klas_ptr=i)->cijfer) {
                             ~~~~~~~~~^~~
error: incompatible types when assigning to type struct student from type int;
    temp = klas_ptr->cijfer;
         ^
error: expected expression before struct;
    (klas_ptr+i)->cijfer = struct student temp;
                           ^~~~~~

regelnummers even weggehaald, omdat die in mijn kopie anders zijn dan de jouwe

En wat ook al is gezegd. Bubble sort sorteert tot er niks meer te sorteren valt. Je hebt dus altijd minimaal 2 loops nodig als je set niet gesorteerd is. De eerste om te sorteren en de tweede om te checken of er nog iets te sorteren is.

[ Voor 5% gewijzigd door CurlyMo op 23-06-2018 21:41 ]

[Onbekend]

Als aanvulling op het antwoord van @eric.1 even in gewone tekst uitgelegd:
Met 1 for-lus ga je 1 getal vergelijken met alle andere getallen en eventueel verplaatsen. Nu wil je het volgende getal vergelijken en op de juiste plaats zetten. En voor deze stap is een tweede for-lus nodig. (Merk op dat die tweede for-lus niet het laatste getal meer hoeft te vergelijken, want die is al tijdens de eerste ronde met elkaar vergeleken.)

[Verwijderd]

Voor je nog een regel code inklopt: leer eerst c! Neem aan dat dit een schoolopdracht is, op welke manier hebben ze je hierin les gegeven?

[farlane]

Verwijderd schreef op zaterdag 23 juni 2018 @ 22:46:
Voor je nog een regel code inklopt: leer eerst c! Neem aan dat dit een schoolopdracht is, op welke manier hebben ze je hierin les gegeven?

Hoe anders dan door code te kloppen leer je C dan? Volgens mij is hij aan het leren, vandaar de beginnersvraag.

[Verwijderd]

Door iets te implementeren dat je begrijpt. Nu snapt ts en de taal niet, en het algorithme is volledig duister. Er zijn allerlei beginnersmogelijkheden om c te leren. Daar hoort ook debuggen bij en iets weten van compileropties. Hoe kan ts zeggen dat de code eindelijke compileert, maar alleen nog niet werkt, als het de code is die ts hier plaatst..

[CurlyMo]

Verwijderd schreef op zaterdag 23 juni 2018 @ 23:52:
Door iets te implementeren dat je begrijpt. Nu snapt ts en de taal niet, en het algorithme is volledig duister. Er zijn allerlei beginnersmogelijkheden om c te leren. Daar hoort ook debuggen bij en iets weten van compileropties. Hoe kan ts zeggen dat de code eindelijke compileert, maar alleen nog niet werkt, als het de code is die ts hier plaatst..

Het implementeren van bubblesort is best een leuke beginners oefening. Alleen dat doen met structs en pointers is alweer wat anders. Een van mijn eerste opgave op mijn ICT opleiding was het vinden van een route door een labyrint in Pascal Gebruikte algoritme boeide niet, als je maar creatief een oplossing wist te bedenken.

@sadiek was het je wel al gelukt om bubblesort toe te passen op een array van integers? En als je die integers nu eens vervangt door strings? Bijvoorbeeld het op volgorde zetten van de letters in het woord "bijvoorbeeld" met bubblesort waarbij de uitkomst: bbeedijloovr moet zijn. Probeer daarna eens een functie te maken die een struct kopieert in een andere struct om dan als laatste bubblesort met structs toe te passen?

[ Voor 8% gewijzigd door CurlyMo op 23-06-2018 23:58 ]

[sadiek]

@CurlyMo ik heb een programmatje gemaakt die een array met cijfers sorteert.

Ben een stukje verder gekomen met mijn programma. Het programma print nu de initiele lijst. dan laat ik hem door de bubblesort gaan, en dan print hij de nieuwe lijst. vreemd genoeg is de tweede lijst hetzelfde als de eerste lijst.
Wat gaat er nog fout?
(oja ik gebruik nu geen pointers, dat is dan de volgende stap weer)

code:

#include <stdio.h>
#include <stdlib.h>

#define KLASGROOTTE 100

//Creeer een nieuw type struct met de naam 'student'
struct student {
    //This structure has 2 elements
    int studentnummer;
    int cijfer;
};

void array_sort (struct student *klas_ptr, int array_lengte);   // prototype van de funktie array_sort

int main()
{
    //Declareer een array van 100 "student" structs
    struct student klas[KLASGROOTTE];
    //Declareer een pointer naar het type struct student
    struct student *klas_ptr;
    int i, teller = 0;

    //Geef een studentnummer en cijfer aan alle 'student' structs in de array
    for (i=0; i<KLASGROOTTE; i++) {
        klas[i].studentnummer = i*10+105;
        //Geef een random cijfer tussen 0 - 99 aan elke student door rand() % 100 te nemen
        klas[i].cijfer = rand() % 100;
    }

    //Geef de pointer de waarde van het beginadres (het adres van klas[0]) van de array klas
    klas_ptr = &klas;
    //Print scores en  bereken het aantal onvoldoendes
    for (i=0; i < KLASGROOTTE; ++i) {
        //Hier gebruiken we de '->' operator om te wijzen naar het genoemde element in de struct
        printf("Student %d heeft een cijfer %d\n", klas_ptr -> studentnummer, klas_ptr -> cijfer);
        if (klas_ptr -> cijfer < 55)
            teller++;    //Incrementeren laat de pointer wijzen naar de volgende struct in de array
        klas_ptr++;
    }
    printf("\nTotaal onvoldundige cijfers = %d\n", teller);

    void array_sort(struct student klas[KLASGROOTTE], int array_lengte );
    
    // print opnieuw , nu gesorteerd
    klas_ptr = &klas;
    for (i=0; i < KLASGROOTTE; ++i) {
        //Hier gebruiken we de '->' operator om te wijzen naar het genoemde element in de struct
        printf("Student %d heeft een cijfer %d\n", klas_ptr -> studentnummer, klas_ptr -> cijfer);
        if (klas_ptr -> cijfer < 55)
            teller++;    //Incrementeren laat de pointer wijzen naar de volgende struct in de array
        klas_ptr++;
    }

    return 0;
}

void array_sort (struct student klas[KLASGROOTTE], int array_lengte)
{
    struct student temp;
    int i, j;

    for(i=0; i < array_lengte-1; i++) {
            for(j = 0; j < (array_lengte-1-i); j++){
                if(klas[j].cijfer < klas[j+1].cijfer){
                    temp = klas[j];
                    klas[j]=klas[j+1];
                    klas[j+1] = temp;
                }
            }
    }
}

[CurlyMo]

1. Je test met veel te grote sets. Begin gewoon eens met een KLASGROOTTE is 5. Anders is het veel te lastig controleren wat er gebeurd.

Wat er nog mis gaat:
- Op regel 42 roep je geen functie aan, maar declareer je de functie opnieuw.
- Deze twee foutmeldingen moet je nog oplossen:

code:

test.c: In function ‘main’:
test.c:31:14: warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
     klas_ptr = &klas;
              ^
test.c:45:14: warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
     klas_ptr = &klas;

Ik kan vast verklappen dat als je dat gedaan hebt je sortering werkt.

Aanvullend:
- Let verder op je Nederlands. Funktie schrijf je niet met een K.
- Wat ik ook raar vind is dat je op twee manieren een struct array uitleest. Op regel 25 doe je klas[i] op regel 38 klas_ptr++, waarom niet structureel het een of het ander?
- Op regel 50 tel je opnieuw, maar daar doe je niks mee. De waarde van die teller klopt daarna in ieder geval niet meer bij wat je doel is.

[Hopscotch]

Een van de belangrijkste lessen die ook anderen hier aan je mee willen geven is dat je zelf moet uit kunnen zoeken wat er fout gaat. Daar leer je van wat er nu echt gebeurd en waarom en daar word je beter van.

Je kunt een debugger gebruiken, dat is een soort programmaatje dat met jouw programma meeloopt en waarin je kunt zien waar in de code jouw programma nu is en welke waardes de variabelen hebben op dat moment. Ik ben niet zo bekend met c en weet niet wat voor debuggers er zijn, maar ook zonder debugger kan je deze informatie achterhalen door je programma dingen uit te laten printen op bepaalde plekken.

code:

void array_sort (struct student klas[KLASGROOTTE], int array_lengte)
{
    struct student temp;
    int i, j;

    for(i=0; i < array_lengte-1; i++) {
            printf("buitenste loop, waarde i: %d\n", i);
            for(j = 0; j < (array_lengte-1-i); j++){
                printf("binneneste loop, waarde j: %d\n", j);
                printf("waarde klas[j].cijfer: %d\n");
                if(klas[j].cijfer < klas[j+1].cijfer){
                    temp = klas[j];
                    klas[j]=klas[j+1];
                    klas[j+1] = temp;
                }
            }
    }
}

Op die manier kan je steeds checken wat de waardes zijn van je variabelen op verschillende plekken in je code en kan je zien of die waardes zijn wat je verwacht dat ze zijn of dat ze afwijken. Als ze afwijken kan je verder onderzoeken waarom de waardes niet zijn zoals je verwacht wat ze zijn.

[sadiek]

Wat er nog mis gaat:
- Op regel 42 roep je geen functie aan, maar declareer je de functie opnieuw.
- Deze twee foutmeldingen moet je nog oplossen:

.

regel 42 veranderd naar: array_sort(klas, i );
klas_ptr = klas; << hier de &-teken weggehaald

En nu sorteert hij de lijst wel, dankjewel @CurlyMo

[CurlyMo]

Knoop daarbij goed in de oren wat @Hopscotch nog concreter zegt dan dat de rest dat heeft gedaan. De debugger heet trouwens gdb. Maar dan moet je wel meer weten van de compileer opties van C zoals @Verwijderd, anders ga je nog niks met de debugger kunnen.

Ook maar goed dat ik niet op je aanbod via de PM ben ingegaan. Nu heb je er zelf tenminste wat van geleerd (hoop ik in ieder geval).

PS. @Hopscotch regel 10 van je voorbeeld bevat een foutje.

[ Voor 7% gewijzigd door CurlyMo op 24-06-2018 13:19 ]

[sadiek]

@CurlyMo achteraf is het zo simpel, je moet maar net de trick weten.
Ik houd gdb in mn achterhoofd

[CurlyMo]

sadiek schreef op zondag 24 juni 2018 @ 13:23:
@CurlyMo achteraf is het zo simpel, je moet maar net de trick weten.
Ik houd gdb in mn achterhoofd

Een aanvullende tip voor jou en anderen die dit topic lezen.

Door de loops zo aan te passen houdt je de pointer van de struct array klas op positie 0.

C:

for (i=0; i < KLASGROOTTE; ++i) {
    printf("Student %d heeft een cijfer %d\n", klas[i].studentnummer, klas[i].cijfer);
    if(klas[i],cijfer < 55)
        teller++;
}

Dan heb je klas_ptr niet meer nodig als tijdelijke variabele. Precies zoals je het ook in de sorteer functie doet.

[GlowMouse]

Gdb is nergens voor nodig als je een goede IDE hebt. Je hebt dan meer aan zorgvuldig geplaatste breakpoints en step into/step out/step over.

CurlyMo schreef op zondag 24 juni 2018 @ 12:50:
Let verder op je Nederlands.

[ Voor 63% gewijzigd door GlowMouse op 24-06-2018 13:34 ]

[CurlyMo]

GlowMouse schreef op zondag 24 juni 2018 @ 13:30:
Gdb is nergens voor nodig als je een goede IDE hebt. Je hebt dan meer aan zorgvuldig geplaatste breakpoints en step into/step out/step over.

[...]

Ik mag ook best het goede voorbeeld geven, maar het voordeel is wel dat ik geen schoolopgave hoef ik te leveren en ik terwijl ik lekker in C aan het programmeren TS probeer te helpen. Dan wortel je wat slordig

[ Voor 13% gewijzigd door CurlyMo op 24-06-2018 13:37 ]

[Matis]

GlowMouse schreef op zondag 24 juni 2018 @ 13:30:
Gdb is nergens voor nodig als je een goede IDE hebt. Je hebt dan meer aan zorgvuldig geplaatste breakpoints en step into/step out/step over.

Je IDE gebruikt toch ook gdb? Met het enige verschil dat ze er een grafische schil omheen legt.

Verder ben ik het met je eens. Een goede IDE hint al op een aantal fouten in je code en kan vaak middels auto completion de juiste velden tonen.

[GlowMouse]

Matis schreef op zondag 24 juni 2018 @ 13:55:
[...]

Je IDE gebruikt toch ook gdb? Met het enige verschil dat ze er een grafische schil omheen legt.

Als de GNU compiler collection gebruikt wel

[farlane]

CurlyMo schreef op zondag 24 juni 2018 @ 12:50:
1. Je test met veel te grote sets. Begin gewoon eens met een KLASGROOTTE is 5. Anders is het veel te lastig controleren wat er gebeurd.

Aanvullend:
- Let verder op je Nederlands. Funktie schrijf je niet met een K.

[CurlyMo]

farlane schreef op zondag 24 juni 2018 @ 16:14:
[...]

@GlowMouse was je voor wat betreft mijn Nederlands