Algorithmen_Datenstrukturen/Uebung 6/Uebung6_1/main.cpp

#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);
}