A3_DobleSpiel/numbers.c

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include "numbers.h"
#include "bintree.h"

// Vergleichsfunktion fuer qsort und den Binaerbaum
static int compareUnsignedInt(const void *arg1, const void *arg2)
{
    unsigned int number1 = *(const unsigned int *)arg1;
    unsigned int number2 = *(const unsigned int *)arg2;

    if(number1 < number2)
    {
        return -1;
    }

    if(number1 > number2)
    {
        return 1;
    }

    return 0;
}
//TODO: getDuplicate und createNumbers implementieren
/*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
  * Duplizieren eines zufälligen Eintrags im Array.
  * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */

// Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
// creating random numbers.
unsigned int *createNumbers(unsigned int len)
{
    // Ungueltige Groesse abfangen
    if(len < 2)
    {
        return NULL;
    }

    // Speicher fuer das Zahlenarray reservieren
    unsigned int *numbers = malloc(len * sizeof(unsigned int));

    if(numbers == NULL)
    {
        return NULL;
    }

    TreeNode *root = NULL;
    unsigned int filledNumbers = 0;

    srand((unsigned int)time(NULL));

    // Solange Zahlen erzeugen bis len - 1 Plaetze gefuellt sind
    while(filledNumbers < len - 1)
    {
        // Zufallszahl zwischen 1 und 2 * len erzeugen
        unsigned int randomNumber = (rand() % (2 * len)) + 1;

        int isDuplicate = 0;

        // Zahl in den Baum einfuegen
        root = addToTree(root,
                         &randomNumber,
                         sizeof(unsigned int),
                         compareUnsignedInt,
                         &isDuplicate);

        // Nur speichern wenn sie noch nicht existiert
        if(isDuplicate == 0)
        {
            numbers[filledNumbers] = randomNumber;
            filledNumbers++;
        }
    }

    // Zufaellige vorhandene Zahl auswaehlen
    unsigned int duplicateIndex = rand() % (len - 1);

    // Diese Zahl absichtlich doppelt speichern
    numbers[len - 1] = numbers[duplicateIndex];

    // Speicher des Baumes freigeben
    clearTree(root);

    return numbers;
}

// Returns only the only number in numbers which is present twice. Returns zero on errors.
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
    // Fehlerfaelle pruefen
    if(numbers == NULL || len < 2)
    {
        return 0;
    }

    // Kopie erzeugen da qsort das Array veraendert
    unsigned int *copy = malloc(len * sizeof(unsigned int));

    if(copy == NULL)
    {
        return 0;
    }

    // Originalarray kopieren
    memcpy(copy, numbers, len * sizeof(unsigned int));

    // Zahlen sortieren
    qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);

    // Nach dem Sortieren stehen Duplikate nebeneinander
    for(unsigned int i = 0; i < len - 1; i++)
    {
        if(copy[i] == copy[i + 1])
        {
            unsigned int duplicate = copy[i];

            free(copy);

            return duplicate;
        }
    }

    free(copy);

    return 0;
}