4. sortieren von struct array

sortieren von struct array

  • ?

    hi!
    ich habe eine struktur:

    struct Mitarbeiter
{	
	char vorname[100];
	char nachname[100];
	unsigned personalnummer;
	unsigned alter;
	bool geschlecht;
	float gehalt;
};

    das feld von strukturen wird so initialisiert:

    void initialisierung(Mitarbeiter Mitarbeiter_Feld[])
{
	strcpy(Mitarbeiter_Feld[0].vorname,"Hans");
	strcpy(Mitarbeiter_Feld[0].nachname,"Haider");
	Mitarbeiter_Feld[0].personalnummer=2;
	Mitarbeiter_Feld[0].alter=32;
	Mitarbeiter_Feld[0].gehalt=1200;
	Mitarbeiter_Feld[0].geschlecht=true;

	strcpy(Mitarbeiter_Feld[1].vorname,"Irene");
	strcpy(Mitarbeiter_Feld[1].nachname,"Blabla");
	Mitarbeiter_Feld[1].personalnummer=1;
	Mitarbeiter_Feld[1].alter=28;
	Mitarbeiter_Feld[1].gehalt=1000;
	Mitarbeiter_Feld[1].geschlecht=false;

	strcpy(Mitarbeiter_Feld[2].vorname,"Tina");
	strcpy(Mitarbeiter_Feld[2].nachname,"Wert");
	Mitarbeiter_Feld[2].personalnummer=3;
	Mitarbeiter_Feld[2].alter=31;
	Mitarbeiter_Feld[2].gehalt=1250;
	Mitarbeiter_Feld[2].geschlecht=false;
}

    und ich möchte gerne diese struktur nach personalnummern sortieren!!
    jedoch weiß ich nicht wie ich die quicksort funktion da anwenden soll....

    void sort (int [] array) 
{ 
      quickSort (array,0,array.length - 1); 
} 

void quickSort(int in_array[], int left, int right) 
{ 
	int current, last; 
    if (left >= right) return; 
    swap(in_array, left, (left+right)/2); 
    last = left; 
    for (current = left + 1; current <= right; current++) 
    { 
       if (in_array[current] < in_array[left]) 
          swap(in_array, ++last, current); 
    } 
    swap(in_array, left, last); 
    quickSort(in_array, left, last-1); 
    quickSort(in_array, last+1, right); 
} 

void swap(int in_array[], int i, int j) 
{ 
	int temp; 
    temp = in_array[i]; 
    in_array[i] = in_array[j]; 
    in_array[j] = temp; 
}

    vielleicht kann ja jemand helfen...wäre fein!

    cu 😃

    0
  • A

    Da musst du dir wohl selber einen Quicksort programmieren müssen. Den Quicksort, den du da gepostet hast, ist nur für int-Arrays. Außerdem kommt mir da was in der Funktion sort() verdächtig vor. Ich bezweifle, dass man in ANSI-C die Länge des Arrays mittels array.length ermitteln kann.

    Wie ein Quicksort funktioniert ersiehst du ja aus den Funktionen, die du gepostet hast. Wobei ich eine etwas andere Variante kenne, aber solange es so funktioniert wie es funktionieren soll ;). Du musst hald die entsprechenden Stellen umbauen:

    - Überprüfung (if (in_array[current] < in_array[left])) und
    -> da musst du hald deine Personalnummer vergleichen
    - swap()
    -> da musst du die gesamte Struktur umschichten

    Eine andere Möglichkeit, die mir gerade einfällt, wäre, dass du deine Personalnummer in einem int-Array speicherst diese dann durch den Quicksort jagst und danach ein neues Struct-Array mittels dem sortierten int-Array aufbaust, dass dann logischerweise auch sortiert.

    0
  • ?

    AJ schrieb:

    - Überprüfung (if (in_array[current] < in_array[left])) und
    -> da musst du hald deine Personalnummer vergleichen
    - swap()
    -> da musst du die gesamte Struktur umschichten

    hi!!
    ja das überprüfen mach i dann so:
    if (in_array[current].personalnummer < in_array[left].personalnummer))

    aber das umschichten????? weiß net wie ich das machen soll....hmmm

    cu

    0
  • A

    Ganz einfach mit memcpy().

    struct Mitarbeiter temp;

memcpy(&temp, in_array+i, sizeof(struct Mitarbeiter));
memcpy(in_array+i, in_array+j, sizeof(struct Mitarbeiter));
memcpy(in_array+j, &temp, sizeof(struct Mitarbeiter));
    0
  • M

    Ok, da ich heute sehr viel Zeit hatte hab ich einfach mal eine Lösung erstellt. Allerdings hab ich zur Lösung nicht den Quicksort verwendet, sondern den Bubble Sort (Wie der Quicksort funktioniert konnte ich mir noch nie merken 😃 ).
    Der Bubble Sort ist auch noch nicht optimiert, allerdings müsste das jetzt so richtig laufen. Vielleicht hilft dir das ja 😉
    Ach, übrigens hab ich in deiner Struktur eine Veränderung vorgenommen und zwar den Typ bool ersetzt. Soweit ich nämlich gelernt habe ist bool kein Bestandteil von ANSI C sondern eine C++ Erweiterung, das aber nur am Rande...

    #include <stdio.h>
#include <string.h>

struct Mitarbeiter
{     
    char vorname[100]; 
    char nachname[100]; 
    unsigned int personalnummer;
    unsigned int alter;
    int geschlecht;
    float gehalt; 
};

void initialisierung(struct Mitarbeiter Mitarbeiter_Feld[]) ;
void ausgabe(struct Mitarbeiter Mitarbeiter_Feld[]);
void sortieren(struct Mitarbeiter Mitarbeiter_Feld[]);

int main(int argc, char *argv[])
{

  struct Mitarbeiter M1[5];
  initialisierung(M1);
  ausgabe(M1);
  sortieren(M1);
  ausgabe(M1);

  getch();
  return 0;
}

void initialisierung(struct Mitarbeiter Mitarbeiter_Feld[])
{ 
    strcpy(Mitarbeiter_Feld[0].vorname,"Hans"); 
    strcpy(Mitarbeiter_Feld[0].nachname,"Haider"); 
    Mitarbeiter_Feld[0].personalnummer=5;
    Mitarbeiter_Feld[0].alter=32; 
    Mitarbeiter_Feld[0].gehalt=1200; 
    Mitarbeiter_Feld[0].geschlecht=0;

    strcpy(Mitarbeiter_Feld[1].vorname,"Irene"); 
    strcpy(Mitarbeiter_Feld[1].nachname,"Blabla"); 
    Mitarbeiter_Feld[1].personalnummer=4;
    Mitarbeiter_Feld[1].alter=28; 
    Mitarbeiter_Feld[1].gehalt=1000; 
    Mitarbeiter_Feld[1].geschlecht=1;

    strcpy(Mitarbeiter_Feld[2].vorname,"Tina"); 
    strcpy(Mitarbeiter_Feld[2].nachname,"Wert"); 
    Mitarbeiter_Feld[2].personalnummer=6;
    Mitarbeiter_Feld[2].alter=31; 
    Mitarbeiter_Feld[2].gehalt=1250; 
    Mitarbeiter_Feld[2].geschlecht=1;

    strcpy(Mitarbeiter_Feld[3].vorname,"Bert");
    strcpy(Mitarbeiter_Feld[3].nachname,"Wert");
    Mitarbeiter_Feld[3].personalnummer=2;
    Mitarbeiter_Feld[3].alter=31;
    Mitarbeiter_Feld[3].gehalt=1250;
    Mitarbeiter_Feld[3].geschlecht=0;

    strcpy(Mitarbeiter_Feld[4].vorname,"Erni");
    strcpy(Mitarbeiter_Feld[4].nachname,"Wert");
    Mitarbeiter_Feld[4].personalnummer=1;
    Mitarbeiter_Feld[4].alter=31;
    Mitarbeiter_Feld[4].gehalt=1250;
    Mitarbeiter_Feld[4].geschlecht=0;
}

void ausgabe(struct Mitarbeiter Mitarbeiter_Feld[]) {

     int i;
     for(i=0;i<=4;i++)
     {
             printf("%s\n", Mitarbeiter_Feld[i].vorname);
             printf("%i\n\n", Mitarbeiter_Feld[i].personalnummer);
     }
}

void sortieren(struct Mitarbeiter Mitarbeiter_Feld[]) {

     int i=4, save;
     struct Mitarbeiter temp;
     int un_sort=1;

     save=i;
     while(un_sort==1)
     {
       un_sort=0;
       i=save;
       for(;i>0;i--)
       if(Mitarbeiter_Feld[i].personalnummer<Mitarbeiter_Feld[i-1].personalnummer)
       {
         temp=Mitarbeiter_Feld[i];
         Mitarbeiter_Feld[i]=Mitarbeiter_Feld[i-1];
         Mitarbeiter_Feld[i-1]=temp;

         un_sort=1;
       }
     }

}
    0
  • S

    Maquis schrieb:

    Ok, da ich heute sehr viel Zeit hatte hab ich einfach mal eine Lösung erstellt. Allerdings hab ich zur Lösung nicht den Quicksort verwendet, sondern den Bubble Sort (Wie der Quicksort funktioniert konnte ich mir noch nie merken 😃 ).

    hi!! danke mal für bubble sort;-) wie müsste ich das für Quicksort umschreiben?? ich kenn weiß von bubblesort nur das es sehr langsam ist....
    vielleicht kannst du mir bei quikesort no helfen wenn zeit hast;-)
    danke erst mal;-)

    cu

    0
  • ?

    hab bissi was umgebaut:

    void sort (struct array[], int feldgroesse)  
{  
      quickSort (array,0, feldgroesse - 1);  
}  

void quickSort(struct array[], int left, int right)  
{  
    int current, last;  
    if (left >= right) return;  
    swap(in_array, left, (left+right)/2);  
    last = left;  
    for (current = left + 1; current <= right; current++)  
    {  
       if (in_array[current].personalnummer < in_array[left].personalnummer)  
          swap(in_array, ++last, current);  
    }  
    swap(in_array, left, last);  
    quickSort(in_array, left, last-1);  
    quickSort(in_array, last+1, right);  
}  

void swap(struct Mitarbeiter[], int i, int j)  
{  
    struct Mitarbeiter temp; 

    memcpy(&temp, in_array+i, sizeof(struct Mitarbeiter)); 
    memcpy(in_array+i, in_array+j, sizeof(struct Mitarbeiter)); 
    memcpy(in_array+j, &temp, sizeof(struct Mitarbeiter));
}

    was meinst du dazu?

    0
  • A

    Der bubble-sort ist wohl eine der langsamsten Sortiermethoden, auch wenn er leicht zu erlernen ist.

    Der "Quicksort", der hier bereits gepostet wurde, ist auch nicht ganz das wahre. Hab ihn mir jetzt mal genauer angesehen. Am besten sucht man über google mit dem Suchbegriff quicksort. Dann findet man Massenhaft Seiten auf denen der Quicksort erklärt wird, teilweise ist sogar Pseudo- oder Quellcode dabei. Man kann es also ganz leicht nachprogrammieren bzw. übernehmen (eigenerprobt :)).

    0
  • ?

    hi es funzt, yeah;-)

    siehe da:
    http://www.c-plusplus.net/forum/viewtopic.php?t=63650

    viel spaß;-)

    cu

    0
Anmelden zum Antworten