home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 02 / extra / prtsort.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-11-28  |  3.7 KB  |  136 lines
  1. /*********************************************************/
  2. /*                     PRTSORT.C                         */
  3. /*      Sortroutinen-Demo mit Funktionsparameter         */
  4. /*             (C) 1988 M.Schlöter & TOOLBOX             */
  5. /*********************************************************/
  6.  
  7. #define real float /* ggf. auch double */
  8. #define MAXINTS 20    /* Größe des Sortierfeldes */
  9. #define MAXREALS 10
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>  /* Für Zufallszahlen */
  13.  
  14. /* Prototype von Sort, Parameter s.u. */
  15. void sort(void *,int,int,
  16.           int (* comp_less)(void *, void *),
  17.       void (* swap)(void *, void *)       );
  18.  
  19. /* Sort selber */
  20. void sort(f,size,elemsize,comp_less,swap)
  21.  
  22.   void *f;                       /* Das Feld            */
  23.   int size,                      /* Anzahl Feldelemente */
  24.       elemsize;             /* Größe eines Feldelements */
  25.   /* Zeiger auf Vergleichsfunktion */
  26.   int (*comp_less)(void *, void *);
  27.   /* Zeiger auf Tauschfunktion */
  28.   void (*swap)(void *, void *);
  29.  
  30. {
  31.   int swaped,   /* Hat eine Vertauschung stattgefunden ? */
  32.       i;        /* Zählvariable                          */
  33.   void *p1, *p2;/* Zwei Zeiger in das Feld               */
  34.  
  35.   do{ /* Feld durchsuchen bis kein Tauschen mehr nötig */
  36.     swaped = 0;           /* Nichts mehr zu tauschen ? */
  37.     for(i = 0, p1 = f; i < size-1; i++){
  38.       /* Einmal durch das Feld, p1 zeigt auf f[i], */
  39.       /* p2 zeigt auf f[i+1]                       */
  40.       p2 = (void *)( (int)p1 + elemsize);/* p2 eins vor p1*/
  41.       if (comp_less(p2,p1)) {          /* f[i] > f[i+1] ? */
  42.     swap(p1,p2);                   /* dann tauschen ! */
  43.     swaped = 1;
  44.       }
  45.       p1 = (void *)( (int)p1 + elemsize);/* p1 eins weiter*/
  46.     }
  47.   } while (swaped);
  48. }
  49.  
  50. /* Prototypen der Vergleichs- und Tauschfunktionen */
  51. int int_compare_less(int *, int *);
  52. int real_compare_less(real *, real *);
  53. void int_swap(int *, int*);
  54. void real_swap(real *, real*);
  55.  
  56. /* Vergleichsfunktion f. INT's */
  57. int int_compare_less(p1,p2)
  58.   int *p1, *p2;   /* Zeiger auf Integer-Feldelemente */
  59. {
  60.   return (*p1 < *p2); /* Vergleichen und zurückgeben */
  61. }
  62.  
  63.  
  64. /* Vergleichsfunktion f. REAL's */
  65. int real_compare_less(p1,p2)
  66.   real *p1, *p2;   /* Zeiger auf REAL-Feldelemente */
  67. {
  68.   return (*p1 < *p2); /* Vergleichen und zurückgeben */
  69. }
  70.  
  71.  
  72. /* Tauschfunktion f. INT's */
  73. void int_swap(p1,p2)
  74.   int *p1, *p2;
  75. {
  76.   int temp;
  77.  
  78.   temp = *p1; /* übliche Tauschoperation */
  79.   *p1 = *p2;
  80.   *p2 = temp;
  81. }
  82.  
  83.  
  84. /* Tauschfunktion f. REAL's */
  85. void real_swap(p1,p2)
  86.   real *p1, *p2;
  87. {
  88.   real temp;
  89.  
  90.   temp = *p1; /* übliche Tauschoperation */
  91.   *p1 = *p2;
  92.   *p2 = temp;
  93. }
  94.  
  95.  
  96. /*---- Hauptprogramm */
  97. main()
  98. {
  99.   int int_Feld[MAXINTS];
  100.   real real_Feld[MAXREALS];
  101.   int i;
  102.  
  103.   /* Felder mit Zufallszahlen inititalisieren */
  104.   for(i = 0; i < MAXINTS; i++)
  105.     int_Feld[i] = rand();
  106.   for(i = 0; i < MAXREALS; i++)
  107.     real_Feld[i] = 3.1415 * rand();
  108.  
  109.   printf("Das Integer-Feld vor der Sortierung:\n");
  110.   for(i = 0; i < MAXINTS; i++)
  111.     printf("%10d",int_Feld[i]);
  112.  
  113.   /* Sortierung des INTEGER-Felds */
  114.   sort( int_Feld, MAXINTS, sizeof(int),
  115.     int_compare_less, int_swap);
  116.  
  117.   printf("\n\nDas Integer-Feld NACH der Sortierung:\n");
  118.   for(i = 0; i < MAXINTS; i++)
  119.     printf("%10d",int_Feld[i]);
  120.  
  121.   printf("\n\n\nDas Real-Feld vor der Sortierung:\n");
  122.   for(i = 0; i < MAXREALS; i++)
  123.     printf("%20.5f",real_Feld[i]);
  124.  
  125.   /* Sortierung REAL-Feld, DIESELBE SORTIERROUTINE !!!!! */
  126.   sort( real_Feld, MAXREALS, sizeof(real),
  127.     real_compare_less, real_swap);
  128.  
  129.   printf("\n\nDas Real-Feld NACH der Sortierung:\n");
  130.   for(i = 0; i < MAXREALS; i++)
  131.     printf("%20.5f",real_Feld[i]);
  132. }
  133.  
  134.  
  135.  
  136.