removed pointers from insertsort.cpp and made it return an array. Trying the same with mergesort.cpp

Makefile

@@ -2,16 +2,21 @@ CC=g++
 DEV=-Wall -g -std=c++14
 OPT=-O3 -std=c++14
 
+JSON=json.hpp
+
 SORTING_SOURCES=insertionsort.cpp mergesort.cpp quicksort.cpp
 SORTING_HEADERS=$(SORTING_SOURCES:.cpp=.h)
 SORTING_DEV_OBJ=$(SORTING_SOURCES:.cpp=.o)
 SORTING_OPT_OBJ=$(SORTING_SOURCES:.cpp=.o3)
 
-EXE_SOURCES=createdata.cxx consistentresultverification.cxx sortedverification.cxx timealgorithms.cxx
-EXE=$(EXE_SOURCES:.cxx=.exe)
+EXPERIMENT_EXE_SOURCES=timealgorithms.cxx
+EXPERIMENT_EXE=$(EXPERIMENT_EXE_SOURCES:.cxx=.exe)
+
+VERIFICATION_EXE_SOURCES=createdata.cxx consistentresultverification.cxx sortedverification.cxx
+VERIFICATION_EXE=$(VERIFICATION_EXE_SOURCES:.cxx=.exe)
 
 .PHONY: all
-all: sorting_lib $(EXE)
+all: sorting_lib $(EXPERIMENT_EXE) $(VERIFICATION_EXE)
 
 # Sorting library
 .PHONY: $(SORTING_LIB)
@@ -24,7 +29,10 @@ $(SORTING_OPT_OBJ): %.o3: %.cpp %.h
 	$(CC) $(OPT) -c $< -o $@
 
 # Executables
-$(EXE): %.exe: %.cxx
+$(EXPERIMENT_EXE): %.exe: %.cxx $(SORTING_OPT_OBJ)
+	$(CC) $(OPT) $^ -o $@
+
+$(VERIFICATION_EXE): %.exe: %.cxx $(JSON)
 	$(CC) $(DEV) -o $@ $<
 
 # Build
@@ -33,6 +41,7 @@ clean:
 	rm -f *.o
 	rm -f *.o3
 	rm -f *.exe
+	rm -rf *.exe.dSYM
 
 .PHONY: update
 update:

consistentresultverification.cxx

@@ -92,7 +92,7 @@ int main(int argc, char* argv[]) {
                   break;
                 }
               } else if (elementNumber < compareElementNumber) {
-                break; // once it goes over the element number of the first array, the loop shouldn't keep going
+                file1.close();break; // once it goes over the element number of the first array, the loop shouldn't keep going
               }
             }
           }

insertionsort.cpp

@@ -5,32 +5,40 @@
 // Adapted from: Lysecky & Vahid "Data Structures Essentials", zyBooks
 
 #include "insertionsort.h"
+#include <iostream>
+#include <cstdio>
 
-void InsertionSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter) {
+int* InsertionSort(std::vector<int>* numbers){
    int i = 0;
    int j = 0;
    int temp = 0; // Temporary variable for swap
+   int comparisonCounter = 0;
+   int memAccessCounter = 0;
+
+   static int returnCounters[2];
 
    for (i = 1; i < numbers->size(); ++i) {
-     *memAccessCounter++;
-     *comparisonCounter++;
+     memAccessCounter++;
+     comparisonCounter++;
+
       j = i;
       // Insert numbers[i] into sorted part
       // stopping once numbers[i] in correct position
       while (j > 0 && (*numbers)[j] < (*numbers)[j - 1]) {
-        *comparisonCounter++;
-        *memAccessCounter = *memAccessCounter + 2;
+        comparisonCounter++;
+        memAccessCounter = memAccessCounter + 2;
 
          // Swap numbers[j] and numbers[j - 1]
          temp = (*numbers)[j];
-         *memAccessCounter++;
+         memAccessCounter++;
          (*numbers)[j] = (*numbers)[j - 1];
-         *memAccessCounter = *memAccessCounter + 2;
+         memAccessCounter = memAccessCounter + 2;
          (*numbers)[j - 1] = temp;
-         *memAccessCounter++;
+         memAccessCounter++;
          --j;
       }
    }
-
-   return;
+   returnCounters[0] = comparisonCounter;
+   returnCounters[1] = memAccessCounter;
+   return returnCounters;
 }

insertionsort.h

@@ -4,6 +4,12 @@
 // ECS60, UC Davis
 // Adapted from: Lysecky & Vahid "Data Structures Essentials", zyBooks
 
+// include guard
+#ifndef INSSORT_H
+#define INSSORT_H
+
 #include <vector>
 
-void InsertionSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
+int* InsertionSort(std::vector<int>* numbers);
+
+#endif

mergesort.cpp

@@ -5,28 +5,38 @@
 // Adapted from: Lysecky & Vahid "Data Structures Essentials", zyBooks
 
 #include "mergesort.h"
+#include <iostream>
+#include <cstdio>
 
-void MergeSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter) {
-   MergeSortRecurse(numbers, 0, numbers->size() - 1, comparisonCounter, memAccessCounter);
+int* MergeSort(std::vector<int>* numbers) {
+  int comparisonCounter = 0;
+  int memAccessCounter = 0;
+  static int returnCounters[2];
+
+  MergeSortRecurse(numbers, 0, numbers->size() - 1, &comparisonCounter, &memAccessCounter);
+
+  returnCounters[0] = comparisonCounter;
+  returnCounters[1] = memAccessCounter;
+  return returnCounters;
 }
 
 
-void MergeSortRecurse(std::vector<int>* numbers, int i, int k, int *comparisonCounter, int *memAccessCounter) {
+void MergeSortRecurse(std::vector<int>* numbers, int i, int k, int* comparisonCounterPointer, int* memAccessCounterPointer) {
    int j = 0;
 
    if (i < k) {
       j = (i + k) / 2;  // Find the midpoint in the partition
 
       // Recursively sort left and right partitions
-      MergeSortRecurse(numbers, i, j, comparisonCounter, memAccessCounter);
-      MergeSortRecurse(numbers, j + 1, k, comparisonCounter, memAccessCounter);
+      MergeSortRecurse(numbers, i, j, comparisonCounterPointer, memAccessCounterPointer);
+      MergeSortRecurse(numbers, j + 1, k, comparisonCounterPointer, memAccessCounterPointer);
 
       // Merge left and right partition in sorted order
-      Merge(numbers, i, j, k, comparisonCounter, memAccessCounter);
+      Merge(numbers, i, j, k, comparisonCounterPointer, memAccessCounterPointer);
    }
 }
 
-void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounter, int *memAccessCounter) {
+void Merge(std::vector<int>* numbers, int i, int j, int k, int* comparisonCounter, int* memAccessCounter) {
    int mergedSize = k - i + 1;                // Size of merged partition
    int mergePos = 0;                          // Position to insert merged number
    int leftPos = 0;                           // Position of elements in left partition
@@ -43,13 +53,16 @@ void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounte
       if ((*numbers)[leftPos] < (*numbers)[rightPos]) {
         *comparisonCounter++;
         *memAccessCounter = *memAccessCounter + 2;
+        //std::cout << ".." << std::endl;
          mergedNumbers[mergePos] = (*numbers)[leftPos];
          *memAccessCounter++;
+         //std::cout << "." << std::endl;
          ++leftPos;
       }
       else {
          mergedNumbers[mergePos] = (*numbers)[rightPos];
          *memAccessCounter++;
+         //std::cout << "." << std::endl;
          ++rightPos;
 
       }
@@ -60,6 +73,7 @@ void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounte
    while (leftPos <= j) {
       mergedNumbers[mergePos] = (*numbers)[leftPos];
       *memAccessCounter++;
+      //std::cout << "." << std::endl;
       ++leftPos;
       ++mergePos;
    }
@@ -68,6 +82,7 @@ void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounte
    while (rightPos <= k) {
       mergedNumbers[mergePos] = (*numbers)[rightPos];
       *memAccessCounter++;
+      //std::cout << "." << std::endl;
       ++rightPos;
       ++mergePos;
    }
@@ -76,5 +91,6 @@ void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounte
    for (mergePos = 0; mergePos < mergedSize; ++mergePos) {
       (*numbers)[i + mergePos] = mergedNumbers[mergePos];
       *memAccessCounter++;
+      //std::cout << "." << std::endl;
    }
 }

mergesort.h

@@ -4,8 +4,14 @@
 // ECS60, UC Davis
 // Adapted from: Lysecky & Vahid "Data Structures Essentials", zyBooks
 
+// include guard
+#ifndef MESORT_H
+#define MESORT_H
+
 #include <vector>
 
-void MergeSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
-void MergeSortRecurse(std::vector<int>* numbers, int i, int k, int *comparisonCounter, int *memAccessCounter);
-void Merge(std::vector<int>* numbers, int i, int j, int k, int *comparisonCounter, int *memAccessCounter);
+int* MergeSort(std::vector<int>* numbers);
+void MergeSortRecurse(std::vector<int>* numbers, int i, int k, int* comparisonCounter, int* memAccessCounter);
+void Merge(std::vector<int>* numbers, int i, int j, int k, int* comparisonCounter, int* memAccessCounter);
+
+#endif

sortedverification.cxx

@@ -76,4 +76,5 @@ int main(int argc, char* argv[]) {
 
   // JSON output
   std::cout << outputJSON << std::endl;
+  file.close();
 }

timealgorithms.cxx

@@ -7,7 +7,9 @@
 #include <vector>
 
 #include "json.hpp"
-#include "timealgorithms.h"
+//#include "timealgorithms.h"
+#include "insertionsort.h"
+#include "mergesort.h"
 
 int main(int argc, char* argv[]) {
   // read JSON file and store in jsonObject
@@ -23,17 +25,21 @@ int main(int argc, char* argv[]) {
   //int n = jsonObject["metadata"]["arraySize"];
   std::vector<int>* sampleArray = new std::vector<int>();
 
+  // initialize timer
+  time_t timer;
+
   // initialize insertion sort variables
-  int insComparisonCounter;
-  int insMemAccessCounter;
-  //double insTime;
+  int *insReturnArray;
+  double insStartTime;
+  double insTime;
   // initialize merge sort variables
-  //int *merComparisonCounter;
-  //int *merMemAccessCounter;
+  int *mergeReturnArray;
+  double merStartTime;
+  double merTime;
   //double merTime;
   // initialize quick sort variables
-  //int *quickComparisonCounter;
-  //int *quickMemAccessCounter;
+  //int quickComparisonCounter;
+  //int quickMemAccessCounter;
   //double quickTime;
 
   std::string sampleName;     // Sample key name to iterate
@@ -56,17 +62,33 @@ int main(int argc, char* argv[]) {
       std::cout << element << ' ' << std::endl;
   }
 
-  InsertionSort(sampleArray, &insComparisonCounter, &insMemAccessCounter);
+  // insertion sort evaluation
+  insStartTime = time(0);
+  insReturnArray = InsertionSort(sampleArray);
+  insTime = time(0) - insStartTime;
+  std::cout << "insertion sort comparison counter: " << *insReturnArray << std::endl;
+  std::cout << "insertion sort memory access counter: " << *(insReturnArray + 1) << std::endl;
+  std::cout << "wallclock time for insertion sort: " << insTime << std::endl;
+
+  // merge sort evaluation
+  merStartTime = time(0);
+  mergeReturnArray = MergeSort(sampleArray);
+  merTime = time(0) - merStartTime;
+  std::cout << "insertion sort comparison counter: " << *mergeReturnArray << std::endl;
+  std::cout << "insertion sort memory access counter: " << *(mergeReturnArray + 1) << std::endl;
+  std::cout << "wallclock time for insertion sort: " << merTime << std::endl;
+
+
+
   //QuickSort(*underlyingSampleArray, *insComparisonCounter, *insMemAccessCounter);
-  //MergeSort(*underlyingSampleArray, *insComparisonCounter, *insMemAccessCounter);
 
-  //std::cout << "insertion sort memory access counter: " << insMemAccessCounter <<std::endl;
-  //std::cout << "insertion sort comparison counter: " << insComparisonCounter << std::endl;
+
   // initiate CSV file to which data will be written
   //std::ofstream theFile;
   //theFile.open("timingalgorithms.csv");
   //theFile << "Sample,InsertionSortTime,InsertionSortCompares,InsertionSortMemaccess,MergeSortTime,MergeSortCompares,MergeSortMemaccess,QuickSortTime,QuickSortCompares,QuickSortMemaccess,\n";
 
   //theFile.close();
+  file.close();
   return 0;
 }

timealgorithms.h

@@ -1,3 +1,3 @@
-void InsertionSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
-void QuickSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
-void MergeSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
+int* InsertionSort(std::vector<int>* numbers);
+int* QuickSort(std::vector<int>* numbers);
+int* MergeSort(std::vector<int>* numbers);