Add exercises 09.

09/suche/makefile

@@ -0,0 +1,7 @@
+LIBFILES = suche.c ../utils/zahlenEingabe.c ../utils/stoppuhr.c ../utils/zufallsarray.c
+
+sucheTest:
+	gcc -Wall -o sucheTest sucheTest.c $(LIBFILES)
+	
+zaehleVorkommen:
+	gcc -Wall -o zaehleVorkommen zaehleVorkommen.c $(LIBFILES)

09/suche/suche.c

@@ -0,0 +1,14 @@
+// TODO: Beginn
+
+#include <stdlib.h>
+#include "suche.h"
+
+int *binsucheZgr(int suchElem, int *startZgr, int *endZgr)
+{
+    // TODO
+}
+
+int *binsuche(int suchElem, int array[], int anzahl)
+{
+    return binsucheZgr(suchElem, array, array + anzahl - 1);
+}

09/suche/suche.h

@@ -0,0 +1,6 @@
+#ifndef SUCHE_H
+#define SUCHE_H
+
+int *binsuche(int suchElem, int array[], int anzahl);
+
+#endif

09/suche/sucheTest.c

@@ -0,0 +1,78 @@
+/************************************************************************
+ * Das untenstehende Programm ist ein Testlauf für eine Binärsuche. Bei 
+ * einer Binärsuche geht man von (hier im Beispiel aufsteigend) 
+ * sortierten Daten aus, die durchsucht werden sollen. Dabei wird für 
+ * das in der Mitte befindliche Element geprüft, ob das zu suchende 
+ * Element größer oder kleiner ist. Ist es kleiner, wird der Teil links des 
+ * Mittelelements durchsucht, andernfalls der rechte Teil. Für den 
+ * entsprechende Datenanteil beginnt die Suche wie eben beschrieben von 
+ * vorne. Dies wiederholt man, bis man entweder das Element gefunden hat 
+ * oder keine Daten mehr zu durchsuchen sind und das zu suchende Element 
+ * folglich nicht enthalten ist.
+ * 
+ * Vervollständigen Sie das Programm unter suche.h und suche.c, indem Sie
+ * die fehlenden Funktionen ergänzen. Implementieren Sie die Binärsuche 
+ * einmal mit Array-Schreibweise und einmal mit Zeigerschreibweise.
+ * 
+ ***************************************************************************/
+
+#include <stdio.h>
+#include "suche.h"
+#include "../utils/zahlenEingabe.h"
+
+#define MAX_ZAHLEN 100
+
+void gibArrayEin(int array[], int anzahl);
+void gibArrayAus(int array[], int anzahl);
+
+int main()
+{
+    int zahlen[MAX_ZAHLEN];
+    int suchZahl, anzahl;
+    int *suchErg;
+
+    printf("Wie viele Zahlen (max. %d)? ", MAX_ZAHLEN);
+    anzahl = gibMinMaxZahlEin(1, MAX_ZAHLEN);
+
+    printf("Geben Sie %d Zahlen in aufsteigender Reihenfolge ein:\n", anzahl);
+    gibArrayEin(zahlen, anzahl);
+
+    printf("\nDie Daten liegen folgendermassen im Speicher:\n");
+    gibArrayAus(zahlen, anzahl);
+
+    printf("Welche Zahl soll gesucht werden? ");
+    suchZahl = gibZahlEin();
+
+    suchErg = binsuche(suchZahl, zahlen, anzahl);
+
+    if(suchErg == NULL)
+        printf("\nDie Zahl konnte nicht gefunden werden.\n");
+    else
+        printf("\nDie Zahl %d befindet sich an Adresse %p, also an %d. Stelle im sortierten Array.\n", 
+            *suchErg, suchErg, (int)(suchErg - zahlen + 1));
+
+    return 0;
+}
+
+void gibArrayEin(int array[], int anzahl)
+{
+    printf("Geben Sie die 1. Zahl ein: ");
+    array[0] = gibZahlEin();
+
+    for(int i = 1; i < anzahl; i++)
+    {
+        printf("Geben Sie die %d. Zahl ein (min. %d): ", i+1, array[i-1]);
+        array[i] = gibMinZahlEin(array[i-1]);
+    }
+}
+
+void gibArrayAus(int array[], int anzahl)
+{
+    printf("     Adresse     |       Wert\n");
+    printf("-----------------------------------\n");
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf("%p | %16d\n", array+i, array[i]);
+    }
+    printf("\n");
+}

09/suche/zaehleVorkommen.c

@@ -0,0 +1,76 @@
+/**************************************************************
+ * Das untenstehende Programm soll ein Array mit Zufallswerten
+ * belegen, das Array aufsteigend sortieren und anschließend 
+ * ermitteln, wie häufig ein einzugebender Wert im Array vorkommt.
+ * Die Häufigkeit soll einmal naiv ermittelt werden und einmal 
+ * durch Verwendung Ihrer Implementierung für die binäre Suche. 
+ * Das Programm vergleicht anschließend die benötigten Laufzeiten 
+ * für beide Implementierungen.
+ * 
+ * 1. Implementieren Sie zunächst die Sortierung des Zufallsarrays.
+ *    (Die Funktionsaufrufe zur Ermittlung der Vorkommenszahlen müssen 
+ *     dafür auskommentiert werden.)
+ * 2. Implementieren Sie nun die naive Ermittlung der Anzahl an 
+ *    Vorkommen (ohne Binärsuche).
+ * 3. Implementieren Sie nun die Ermittlung der Anzahl an Vorkommen 
+ *    unter Verwendung Ihrer Implementierung der Binärsuche.
+ * 
+ ***************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include "../utils/zufallsarray.h"
+#include "../utils/stoppuhr.h"
+#include "../utils/zahlenEingabe.h"
+#include "suche.h"
+
+#define MAX_ANZAHL 500000
+#define ANZAHL MAX_ANZAHL
+#define MAX    ((int)(ANZAHL * 0.2))
+#define MIN    (-MAX)
+#define MAX_100(n) ((n) < 100 ? n : 100)
+
+int zaehleVorkommenNaiv(int suchElem, int array[], int anzahl);
+int zaehleVorkommenBs(int suchElem, int array[], int anzahl);
+int vergleiche(const void *arg1, const void *arg2);
+void gibArrayAus(int array[], int anzahl);
+
+int main()
+{
+    int suchZahl, anzahlVorkommen;
+    int zufallszahlen[ANZAHL];
+
+    srand(0);
+
+    fuelleArray(zufallszahlen, ANZAHL, MIN, MAX);
+    // TODO: Sortierung mit qsort
+
+    gibArrayAus(zufallszahlen, MAX_100(ANZAHL));
+
+    printf("Welche Zahl soll gesucht werden? ");
+    suchZahl = gibZahlEin();
+
+    printf("Zaehle naiv:\n");
+    starteUhr();
+    anzahlVorkommen = zaehleVorkommenNaiv(suchZahl, zufallszahlen, ANZAHL);
+
+    printf("Die Zahl %d ist %dx enthalten. (%lf Sekunden)\n", suchZahl, anzahlVorkommen, messeZeitInSek());
+
+    printf("Zaehle mit Binaersuche:\n");
+    starteUhr();
+    anzahlVorkommen = zaehleVorkommenBs(suchZahl, zufallszahlen, ANZAHL);
+
+    printf("Die Zahl %d ist %dx enthalten. (%lf Sekunden)\n", suchZahl, anzahlVorkommen, messeZeitInSek());
+
+    return 0;
+}
+
+void gibArrayAus(int array[], int anzahl)
+{
+    printf("Die ersten %d Zufallszahlen: ", anzahl);
+    for(int i = 0; i < anzahl; i++)
+    {
+        printf(" %4d", array[i]);
+    }
+    printf("\n");
+}
+