120 lines
3.0 KiB
C
120 lines
3.0 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include "numbers.h"
|
|
#include "bintree.h"
|
|
|
|
// --- Hilfsfunktion: Vergleich von unsigned int ------------------
|
|
static int compareUInt(const void *a, const void *b)
|
|
{
|
|
unsigned int ua = *(const unsigned int *)a;
|
|
unsigned int ub = *(const unsigned int *)b;
|
|
|
|
if (ua < ub) return -1;
|
|
if (ua > ub) return 1;
|
|
return 0;
|
|
}
|
|
|
|
// --- Hilfsfunktion: Shuffle des Arrays (Fisher-Yates) ------------------
|
|
static void shuffle(unsigned int *array, unsigned int len)
|
|
{
|
|
for (unsigned int i = len - 1; i > 0; i--)
|
|
{
|
|
unsigned int j = rand() % (i + 1);
|
|
unsigned int temp = array[i];
|
|
array[i] = array[j];
|
|
array[j] = temp;
|
|
}
|
|
}
|
|
|
|
// Gibt ein Array mit len zufälligen Zahlen zwischen 1 und 2*len zurück, die alle unterschiedlich sind,
|
|
// außer zwei Einträgen (ein Duplikat). Verwendet den Binärbaum, um Duplikate zu vermeiden.
|
|
unsigned int *createNumbers(unsigned int len)
|
|
{
|
|
// Überprüfe ungültige Länge
|
|
if (len < 2)
|
|
return NULL;
|
|
|
|
// Allokiere Speicher für das Array
|
|
unsigned int *arr = malloc(sizeof(unsigned int) * len);
|
|
if (!arr)
|
|
return NULL;
|
|
|
|
// Initialisiere Zufallszahlengenerator
|
|
srand((unsigned int)time(NULL));
|
|
|
|
TreeNode *root = NULL;
|
|
|
|
unsigned int count = 0;
|
|
// Generiere len-1 eindeutige Zahlen
|
|
while (count < len - 1)
|
|
{
|
|
unsigned int val = (rand() % (2 * len)) + 1;
|
|
|
|
int isDup = 0;
|
|
// Füge in Baum ein und prüfe auf Duplikat
|
|
root = addToTree(root, &val, sizeof(unsigned int), compareUInt, &isDup);
|
|
|
|
if (!isDup)
|
|
{
|
|
arr[count++] = val;
|
|
}
|
|
}
|
|
|
|
// Wähle einen zufälligen bestehenden Wert als Duplikat
|
|
unsigned int duplicateIndex = rand() % (len - 1);
|
|
arr[len - 1] = arr[duplicateIndex];
|
|
|
|
// Shuffle das Array, damit das Duplikat nicht immer am Ende steht
|
|
shuffle(arr, len);
|
|
|
|
// Baum freigeben
|
|
clearTree(root);
|
|
return arr;
|
|
}
|
|
|
|
// Gibt die einzige Zahl im Array zurück, die zweimal vorkommt.
|
|
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
|
|
{
|
|
// Überprüfe ungültige Eingaben
|
|
if (!numbers || len < 2)
|
|
return 0;
|
|
|
|
// Kopiere Array
|
|
unsigned int *copy = malloc(sizeof(unsigned int) * len);
|
|
if (!copy)
|
|
return 0;
|
|
|
|
memcpy(copy, numbers, sizeof(unsigned int) * len);
|
|
|
|
// Sortiere das Array (einfache Bubble-Sort)
|
|
for (unsigned int i = 0; i < len - 1; i++)
|
|
{
|
|
for (unsigned int j = i + 1; j < len; j++)
|
|
{
|
|
if (copy[j] < copy[i])
|
|
{
|
|
unsigned int t = copy[i];
|
|
copy[i] = copy[j];
|
|
copy[j] = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finde angrenzendes Duplikat
|
|
unsigned int duplicate = 0;
|
|
for (unsigned int i = 0; i < len - 1; i++)
|
|
{
|
|
if (copy[i] == copy[i + 1])
|
|
{
|
|
duplicate = copy[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Speicher freigeben
|
|
free(copy);
|
|
return duplicate;
|
|
}
|