soberhofer
/
Algorithmen_Datenstrukturen
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

6.1

This commit is contained in:
Samuel Oberhofer 2022-06-28 21:19:13 +02:00
parent cf6edcdff6
commit a5563a4103
6 changed files with 303 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
Uebung 6/Uebung6_1/Makefile Normal file
View File

@ -0,0 +1,52 @@
# Name of the binary for Development
BINARY = main
# Name of the binary for Release
FINAL = prototyp
# Object files
OBJS = mergeSortRand.o helperFunctions.o main.o
# Compiler flags
CFLAGS = -Werror -Wall -std=c++17 -g#-fsanitize=address,undefined -g
# Linker flags
LFLAGS = #-fsanitize=address,undefined
#Which Compiler to use
COMPILER = g++
# all target: builds all important targets
all: binary
final : ${OBJS}
${COMPILER} ${LFLAGS} -o ${FINAL} ${OBJS}
rm ${OBJS}
binary : ${OBJS}
${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
# Links the binary
${BINARY} : ${OBJS}
${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
# Compiles a source-file (any file with file extension .c) into an object-file
#
# "%" is a wildcard which matches every file-name (similar to * in regular expressions)
# Such a rule is called a pattern rule (because it matches a pattern, see https://www.gnu.org/software/make/manual/html_node/Pattern-Rules.html),
# which are a form of so called implicit rules (see https://www.gnu.org/software/make/manual/html_node/Implicit-Rules.html)
# "$@" and "$<" are so called automatic variables (see https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html)
%.o : %.cpp
${COMPILER} -c ${CFLAGS} -o $@ $<
# Rules can not only be used for compiling a program but also for executing a program
run: ${BINARY}
./${BINARY}
# Delete all build artifacts
clean :
rm -rf ${BINARY} ${OBJS}
# all and clean are a "phony" targets, meaning they are no files
.PHONY : all clean

20
Uebung 6/Uebung6_1/helperFunctions.cpp Normal file
View File

@ -0,0 +1,20 @@
#include "helperFunctions.h"
#include <ctime>
void printArray(int* array, int arrayLength, std::string heading) {
std::cout << "========== " << heading << " ==========" << std::endl;
for(int i = 0; i < arrayLength; i++) {
if(i > 0) {
std::cout << " - ";
}
std::cout << array[i];
}
std::cout << std::endl << "==============================================" << std::endl;
}
void generateRandomIntArray(int* array, int arrayLength) {
std::srand(std::time(NULL));
for(int i = 0; i < arrayLength; i++) {
array[i] = rand() % 100000 + 1;
}
}

7
Uebung 6/Uebung6_1/helperFunctions.h Normal file
View File

@ -0,0 +1,7 @@
#include <string>
#include <iostream>
#pragma once
void generateRandomIntArray(int* array, int arrayLength);
void printArray(int* array, int arrayLength, std::string heading);

157
Uebung 6/Uebung6_1/main.cpp Normal file
View File

@ -0,0 +1,157 @@
#include <iostream>
#include <string>
#include "helperFunctions.h"
#include "mergeSortRand.h"
#include <vector>
#define ARRAY_LENGTH 10
class PerformanceTest {
private:
double minExecutionTime;
double maxExecutionTime;
double totalExecutionTime;
std::string algorithmName;
public:
PerformanceTest() {
this->minExecutionTime = 1000;
this->maxExecutionTime = 0;
this->totalExecutionTime = 0;
this->algorithmName = "";
};
double getMinExecutionTime() { return this->minExecutionTime; }
double getMaxExecutionTime() { return this->maxExecutionTime; }
double getTotalExecutionTime() { return this->totalExecutionTime; }
const std::string &getAlgorithmName() { return this->algorithmName; }
void setAlgorithmName(std::string name) { this->algorithmName = name; }
void processResult(std::chrono::high_resolution_clock::time_point startTime,
std::chrono::high_resolution_clock::time_point endTime) {
std::chrono::duration<double, std::milli> duration = (endTime - startTime);
double execTime = duration.count();
this->totalExecutionTime += execTime;
if (execTime < this->minExecutionTime) {
this->minExecutionTime = execTime;
return;
} else if (execTime > this->maxExecutionTime) {
this->maxExecutionTime = execTime;
return;
}
}
};
class PerformanceComparison {
private:
int *baseArray;
int arrayLength;
int testsetSize;
std::vector<PerformanceTest *> testResults;
public:
PerformanceComparison(int arrayLength, int testsetSize) {
this->arrayLength = arrayLength;
this->testsetSize = testsetSize;
this->baseArray =
(int *)malloc(sizeof(int) * this->arrayLength * this->testsetSize);
generateRandomIntArray(this->baseArray,
this->arrayLength * this->testsetSize);
}
~PerformanceComparison() {
free(this->baseArray);
for (int i = 0; i < this->testResults.size(); i++) {
free(testResults[i]);
}
}
void runTest(int algorithm) {
PerformanceTest *pt = new PerformanceTest();
if (algorithm == 1) {
pt->setAlgorithmName("MergeSort");
for (int i = 0; i < this->testsetSize; i++) {
int testArray[this->arrayLength];
std::memcpy(testArray, this->baseArray + (this->arrayLength * i),
this->arrayLength * sizeof(int));
auto startTime = std::chrono::high_resolution_clock::now();
mergeSort(testArray, 0, arrayLength - 1);
auto endTime = std::chrono::high_resolution_clock::now();
pt->processResult(startTime, endTime);
}
} else if (algorithm == 2) {
pt->setAlgorithmName("MergeSortRand");
for (int i = 0; i < this->testsetSize; i++) {
int testArray[this->arrayLength];
std::memcpy(testArray, this->baseArray + (this->arrayLength * i),
this->arrayLength * sizeof(int));
auto startTime = std::chrono::high_resolution_clock::now();
mergeSortRand(testArray, 0, arrayLength - 1);
auto endTime = std::chrono::high_resolution_clock::now();
pt->processResult(startTime, endTime);
}
} else {
std::cerr << "Algorithm not recognized!" << std::endl;
exit(1);
}
this->testResults.push_back(pt);
};
void printComparison(int mode) {
if (mode == 1) {
std::cout << "Algorithm\t\tMIN\t\t\tMAX\t\t\tAVG\t\t\tTOTAL" << std::endl;
for (int i = 0; i < this->testResults.size(); i++) {
std::cout << this->testResults[i]->getAlgorithmName() << "\t\t"
<< this->testResults[i]->getMinExecutionTime() << "\t\t"
<< this->testResults[i]->getMaxExecutionTime() << "\t\t"
<< this->testResults[i]->getTotalExecutionTime() /
this->testsetSize
<< "\t\t" << this->testResults[i]->getTotalExecutionTime()
<< std::endl;
}
} else if (mode == 2) {
std::cout << "Algorithm\tTOTAL\t\tAVG" << std::endl;
for (int i = 0; i < this->testResults.size(); i++) {
std::cout << this->testResults[i]->getAlgorithmName() << "\t\t"
<< this->testResults[i]->getTotalExecutionTime() << " \t\t"
<< this->testResults[i]->getTotalExecutionTime() /
this->testsetSize
<< std::endl;
}
} else {
std::cerr << "Mode not recognized!" << std::endl;
exit(1);
}
}
};
int main() {
srand(time(0));
int array[ARRAY_LENGTH];
int array2[ARRAY_LENGTH];
generateRandomIntArray(array, ARRAY_LENGTH);
memcpy(array2, array, ARRAY_LENGTH * sizeof(int));
printArray(array, ARRAY_LENGTH, "Unsortiertes Array");
mergeSort(array, 0, ARRAY_LENGTH - 1);
printArray(array, ARRAY_LENGTH, "Array nach MergeSort");
mergeSortRand(array2, 0, ARRAY_LENGTH - 1);
printArray(array2, ARRAY_LENGTH, "Array nach MergeSortRand");
for (int i = 0; i < ARRAY_LENGTH; i++) {
if (array[i] != array2[i]) {
std::cout << "ERROR" << std::endl;
exit(0);
}
}
PerformanceComparison pc(10, 10000);
pc.runTest(1);
pc.runTest(2);
pc.printComparison(1);
}

62
Uebung 6/Uebung6_1/mergeSortRand.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "mergeSortRand.h"
//#include <cstdlib>
#include <iostream>
void merge(int array[], int left, int middle, int right) {
int n1 = middle - left + 1;
int n2 = right - middle;
int leftArray[n1];
int rightArray[n2];
for (int i = 0; i < n1; i++) {
leftArray[i] = array[left + i];
}
for (int j = 0; j < n2; j++) {
rightArray[j] = array[middle + j + 1];
}
int k = 0, l = 0, m = left;
while (k < n1 && l < n2) {
if (leftArray[k] <= rightArray[l]) {
array[m] = leftArray[k];
k++;
} else {
array[m] = rightArray[l];
l++;
}
m++;
}
while (k < n1) {
array[m] = leftArray[k];
k++;
m++;
}
while (l < n2) {
array[m] = rightArray[l];
l++;
m++;
}
}
void mergeSortRand(int array[], int left, int right) {
if (left < right) {
int middle = (rand() % (right - left + 1)) + left;
if (middle < left || middle > right) {
std::cout << "ERROR2" << std::endl;
}
mergeSortRand(array, left, middle);
mergeSortRand(array, middle + 1, right);
merge(array, left, middle, right);
}
}
void mergeSort(int array[], int left, int right) {
if (left < right) {
int middle = left + (right - left) / 2;
mergeSort(array, left, middle);
mergeSort(array, middle + 1, right);
merge(array, left, middle, right);
}
}

5
Uebung 6/Uebung6_1/mergeSortRand.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
void merge(int array[], int left, int middle, int right);
void mergeSort(int array[], int left, int right);
void mergeSortRand(int array[], int left, int right);