generated from freudenreichan/info2Praktikum-DobleSpiel
103 lines
2.7 KiB
C
103 lines
2.7 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include "numbers.h"
|
|
#include "bintree.h"
|
|
|
|
//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. */
|
|
|
|
//Vergleichsfunktion von qsort
|
|
static int compareUnsignedInt(const void *a, const void *b)
|
|
{
|
|
const unsigned int *x = (const unsigned int *)a;
|
|
const unsigned int *y = (const unsigned int *)b;
|
|
|
|
if (*x < *y) return -1;
|
|
if (*x > *y) return 1;
|
|
return 0;
|
|
}
|
|
|
|
//Mischen des Arrays
|
|
static void shuffleArray(unsigned int *array, unsigned int n)
|
|
{
|
|
if (n > 1)
|
|
{
|
|
for (unsigned int i = n - 1; i > 0; i--)
|
|
{
|
|
unsigned int j = rand() % (i + 1);
|
|
unsigned int temp = array[i];
|
|
array[i] = array[j];
|
|
array[j] = temp;
|
|
}
|
|
}
|
|
}
|
|
//Wenn weniger als zwei Zahlen
|
|
unsigned int *createNumbers(unsigned int len)
|
|
{
|
|
if (len < 2) return NULL;
|
|
|
|
//Dynamisches Array
|
|
unsigned int *numbers = malloc(len * sizeof(unsigned int));
|
|
if (numbers == NULL) return NULL;
|
|
//Variabelen für den Binärbaum
|
|
TreeNode *root = NULL;
|
|
int isDuplicate = 0;
|
|
unsigned int count = 0;
|
|
|
|
|
|
while (count < len - 1)
|
|
{ //Zufallszahlen generieren
|
|
unsigned int value = (rand() % (2 * len)) + 1;
|
|
|
|
|
|
root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
|
|
|
|
if (isDuplicate == 0)
|
|
{ //in array schreiben falls kein Duplikat
|
|
numbers[count] = value;
|
|
count++;
|
|
}
|
|
|
|
}
|
|
//Duplikat erzeugen
|
|
unsigned int randomIndex = rand() % (len - 1);
|
|
unsigned int duplicateValue = numbers[randomIndex];
|
|
numbers[len - 1] = duplicateValue;
|
|
root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);
|
|
//Array mischen damit duplikat nicht am Ende immer ist
|
|
shuffleArray(numbers, len);
|
|
|
|
clearTree(root);
|
|
return numbers;
|
|
}
|
|
//get Duplicate
|
|
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
|
|
{
|
|
if (numbers == NULL || len < 2) {
|
|
return 0;
|
|
}
|
|
//Kopie vom Array anlegen
|
|
unsigned int *copy = malloc(len * sizeof(unsigned int));
|
|
|
|
if (copy == NULL) {
|
|
return 0;
|
|
}
|
|
memcpy(copy, numbers, len * sizeof(unsigned int));
|
|
qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
|
|
unsigned int duplicate = 0;
|
|
//Duplikat finden
|
|
for (unsigned int i = 0; i + 1 < len; ++i) {
|
|
if (copy[i] == copy[i + 1]) {
|
|
duplicate = copy[i];
|
|
break;
|
|
}
|
|
}
|
|
//Speicher freigeben
|
|
free(copy);
|
|
return duplicate;
|
|
} |