91 lines
2.8 KiB
C
91 lines
2.8 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include "numbers.h"
|
|
#include "bintree.h"
|
|
|
|
static int compareInt(const void *ptr1, const void *ptr2);
|
|
|
|
// 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.
|
|
|
|
/*
|
|
the implemented tree can't efficiently check if it contains a specific number, but we don't actually need that anyways
|
|
create numbers just counts and checks if the just inserted number sets the isDuplicate pointer
|
|
*/
|
|
// srand should have been called before this function
|
|
unsigned int *createNumbers(unsigned int len)
|
|
{
|
|
unsigned int *randomNumbers = malloc(len * sizeof(int));
|
|
|
|
if (!randomNumbers)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// including upper limit
|
|
int upperLimit = len * 2;
|
|
|
|
int numberCnt = 0;
|
|
|
|
int isDuplicate = 0;
|
|
TreeNode *root = NULL;
|
|
// we only need len-1 numbers because 1 will be duplicated
|
|
while (numberCnt < len - 1)
|
|
{
|
|
// numbers up to and including upperLimit without 0
|
|
int randNum = rand() % upperLimit + 1;
|
|
// reset isDuplicate
|
|
isDuplicate = 0;
|
|
// don't forget to set the root here
|
|
root = addToTree(root, &randNum, sizeof(randNum), (CompareFctType)compareInt, &isDuplicate);
|
|
if (isDuplicate)
|
|
{
|
|
// number already exists
|
|
continue;
|
|
}
|
|
randomNumbers[numberCnt++] = randNum;
|
|
}
|
|
|
|
// select which number to duplicate
|
|
int dupNum = randomNumbers[rand() % numberCnt];
|
|
// ...and where to insert
|
|
int dupNumIdx = rand() % len;
|
|
|
|
// move the number currently at the dupNumIdx to the end
|
|
// and insert the dupNum at the index
|
|
// this also works if the last idx was selected for dupNum
|
|
randomNumbers[len - 1] = randomNumbers[dupNumIdx];
|
|
randomNumbers[dupNumIdx] = dupNum;
|
|
|
|
// clean up memory
|
|
clearTree(root);
|
|
return randomNumbers;
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
qsort((void *)numbers, len, sizeof(int), compareInt); // sort the array
|
|
for (int i = 0; i < len - 1; i++)
|
|
{
|
|
if (numbers[i] == numbers[i + 1])
|
|
return numbers[i];
|
|
}
|
|
return 0; // zero on errors
|
|
}
|
|
|
|
static int compareInt(const void *ptr1, const void *ptr2)
|
|
{
|
|
int num1 = *(int *)ptr1;
|
|
int num2 = *(int *)ptr2;
|
|
return num1 - num2;
|
|
} |