mergesort mit struckturen



  • huhu,also ich versuche struckturen zu sortieren.ich habe ne struct gemacht und möchte nun nach den punkten(score)sortieren.bekomme immer die fehler meldung cannot convert 'liste' to 'int' in assignment.hat jemand nen tipp?

    /* Autor:         Brian Wetzl
                      1.Semester IIW
       Beschreibung:  Programmiermethodik 1. Semester
                      Projekt
                      Mergesort
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct liste {
           int score;
           char name[12];
    };
    
    struct liste A[5];
    
    void ausgabe(int, int);
    void mergesort(int, int);
    
    int main() {
        A[0].score=111;
        strcpy(A[1].name, "brian");
        A[1].score=90;
        strcpy(A[1].name, "nils");
        A[2].score=85;
        strcpy(A[1].name, "ulli");
        A[3].score=90;
        strcpy(A[1].name, "peter");
        A[4].score=30;
        strcpy(A[1].name, "hans");
    
        ausgabe(0,4);
        mergesort(0,4);
        ausgabe(0,4);
        getchar();
        return 0;
    }
    
    void mergesort(int l, int r){
        int m = (l+r) / 2,  i, a = l, b = m+1;
        int *p = (int *) malloc((r - l + 1) * sizeof(int)); /* Speicherreservierung von 10 Werten für 4 Bytes */
    
        if (l == r) /* Rekursions-Abbruch : Wenn links und rechts auf den gleichen wert zeigen */
            return;
        mergesort(l, m); /* Rekusiver Aufruf */
        mergesort(m+1, r); /* Rekusiver Aufruf */
        for (i=0; i <= r; i++)  /* Mischen : solange bis i so groß wie r ist */
            *(p+i) = (b>r || a <= m && A[a].score < A[b].score) ?  A[a++] : A[b++]; /* pointer wird ein höher im Array der ersten liste geschoben,
                                                                      wenn b größer als r ist oder a kleiner,gleich m und Array a kleiner 
                                                                      Array b, sonst wird pointer höher in der zweiten liste gesetzt */
    
        for (i = 0; i <= r-l; i++) /* zurückkopieren */
            A[l+i].score = *(p+i);
            free(p); /* Speicher freigeben! */
    
    }
    
    void ausgabe(int li, int re) {
        int i;
        printf("li=%d  re=%d", li, re);
        for (i = li; i <= re; i++)
            printf("\t%d", A[i]);
        printf("\n\n");
    }
    


  • *(p+i) = (b>r || a <= m && A[a].score < A[b].score) ?  A[a++] : A[b++];
    

    Dein R-Value ist ein int-Pointer, dein L-Value ein struct liste!



  • jo,hab ich auch bemekrt und korrigiert.mein prob ist jetzt noch,wie ich die namen mit den punkten mitverschiebe.

    /* Autor:         Brian Wetzl
                      1.Semester IIW
       Beschreibung:  Programmiermethodik 1. Semester
                      Projekt
                      Mergesort
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct liste {
           int score;
           char name[12];
    };
    
    struct liste A[5];
    
    void ausgabe(int, int);
    void mergesort(int, int);
    
    int main() {
    
        A[0].score=111;
        strcpy(A[0].name, "brian");
        A[1].score=90;
        strcpy(A[1].name, "nils");
        A[2].score=85;
        strcpy(A[2].name, "ulli");
        A[3].score=90;
        strcpy(A[3].name, "peter");
        A[4].score=30;
        strcpy(A[4].name, "hans");
    
        ausgabe(0,4);
        mergesort(0,4);
        ausgabe(0,4);
        getchar();
        return 0;
    }
    
    void mergesort(int l, int r){
        int m = (l+r) / 2,  i, a = l, b = m+1;
        int *p = (int *) malloc((r - l + 1) * sizeof(int)); /* Speicherreservierung von 10 Werten für 4 Bytes */
    
        if (l == r) /* Rekursions-Abbruch : Wenn links und rechts auf den gleichen wert zeigen */
            return;
        mergesort(l, m); /* Rekusiver Aufruf */
        mergesort(m+1, r); /* Rekusiver Aufruf */
        for (i=0; i <= r; i++)  /* Mischen : solange bis i so groß wie r ist */
            *(p+i) = (b>r || a <= m && A[a].score < A[b].score) ?  A[a++].score : A[b++].score; /* pointer wird ein höher im Array der ersten liste geschoben,
                                                                      wenn b größer als r ist oder a kleiner,gleich m und Array a kleiner 
                                                                      Array b, sonst wird pointer höher in der zweiten liste gesetzt */
    
        for (i = 0; i <= r-l; i++) /* zurückkopieren */
            A[l+i].score = *(p+i);
            free(p); /* Speicher freigeben! */
    
    }
    
    void ausgabe(int li, int re) {
        int i;
        printf("li=%d  re=%d\n\n", li, re);
        for (i = li; i <= re; i++)
            printf("Name: %s %d\t",A[i].name, A[i]);
        printf("\n\n");
    }
    


  • huhu.habe es jetzt überarbeitet,sodass es funktionier.kann mir jetzt noch jemand helfen,dass ich die globalen variablen wegbekomme?

    /* Autor:         Brian Wetzl
                      1.Semester IIW
       Beschreibung:  Programmiermethodik 1. Semester
                      Projekt
                      Mergesort
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MAX_NAME 20
    
    struct liste {
           int score;
           char name[MAX_NAME];
    };
    
    struct liste A[5]; 
    
    void ausgabe(int, int);
    void mergesort(int, int);
    
    int main() {
        int i;
    
        A[0].score=111;
        strcpy(A[0].name, "brian");
        A[1].score=90;
        strcpy(A[1].name, "nils");
        A[2].score=85;
        strcpy(A[2].name, "ulli");
        A[3].score=100;
        strcpy(A[3].name, "peter");
        A[4].score=85;
        strcpy(A[4].name, "hans");
    
        ausgabe(0,4);
        mergesort(0,4);    
        ausgabe(0,4);    
        getchar();
        return 0;
    }
    
    void mergesort(int l, int r) {
         struct liste *n;
         int m = (l+r) / 2,  i,j, a = l, b = m+1;              
         int *p = (int *) malloc((r - l + 1) * sizeof(int)); /* Speicherreservierung: pointer zeigt auf Anfangsadresse des speichers der größe int */
         n = (struct liste *) malloc((r - l + 1) * sizeof(struct liste));
    
         if (l == r) /* Rekursions-Abbruch : Wenn links und rechts auf den gleichen wert zeigen */
            return;
         mergesort(l, m); /* Rekusiver Aufruf */
         mergesort(m+1, r); /* Rekusiver Aufruf */
    
        for (i=0; i <= r; i++) {  /* Mischen : solange bis i so groß wie r ist */ 
            if(b > r || (a <= m && A[b].score < A[a].score)){
              *(n+i) = A[a++];
              }
               else{
               *(n+i) = A[b++];
               }                                                   /* pointer wird ein höher im Array der ersten liste geschoben, */
            }                                                      /* wenn b größer als r ist oder a kleiner,gleich m und Array a kleiner
                                                                     Array b, sonst wird pointer höher in der zweiten liste gesetzt */
        for (i=0; i <= r-l; i++) {                                   /* zurückkopieren */
            A[l+i] = *(n+i);
            }
            free(n);
            free(p); /* Speicher freigeben! */
    
    }
    
    void ausgabe(int li, int re) {
         int i;
    
         for (i = li; i <= re; i++)
            printf("\n Punkte: %d   Name: %s\t\n", A[i].score,A[i].name);
            printf("\n\n");
    }
    


  • indem du das Array per Parameter an deine Funktion übergibst (oder du reichst direkt zwei Pointer auf Start und Ende des zu sortierenden Bereiches weiter):

    //Variante a:
    mergesort(struct liste data[],int st,int en)
    {
      //wie unten, verwendet data[i] statt des globalen A[i]
    }
    
    //Variante b:
    mergesort(struct liste *st,struct liste* en)
    {
      //arbeitet mit Pointern statt mit Indizes
    }
    

Anmelden zum Antworten