all of the sorting algorithms are giving values. Fixed pointer issues like *var++ use

quicksort.cpp

@@ -6,9 +6,16 @@
 
 #include "quicksort.h"
 
+int* QuickSort(std::vector<int>* numbers) {
+  int comparisonCounter = 0;
+  int memAccessCounter = 0;
+  static int returnCounters[2];
 
-void QuickSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter) {
-   QuickSortRecurse(numbers, 0, numbers->size() - 1, comparisonCounter, memAccessCounter);
+  QuickSortRecurse(numbers, 0, numbers->size() - 1, &comparisonCounter, &memAccessCounter);
+
+  returnCounters[0] = comparisonCounter;
+  returnCounters[1] = memAccessCounter;
+  return returnCounters;
 }
 
 void QuickSortRecurse(std::vector<int>* numbers, int i, int k, int *comparisonCounter, int *memAccessCounter) {
@@ -43,7 +50,7 @@ int Partition(std::vector<int>* numbers, int i, int k, int *comparisonCounter, i
    /* Pick middle element as pivot */
    midpoint = i + (k - i) / 2;
    pivot = (*numbers)[midpoint];
-   *memAccessCounter++;
+   *memAccessCounter = *memAccessCounter + 1;
 
    l = i;
    h = k;
@@ -52,15 +59,15 @@ int Partition(std::vector<int>* numbers, int i, int k, int *comparisonCounter, i
 
       /* Increment l while numbers[l] < pivot */
       while ((*numbers)[l] < pivot) {
-        *comparisonCounter++;
-        *memAccessCounter++;
+        *comparisonCounter = *comparisonCounter + 1;
+        *memAccessCounter = *memAccessCounter + 1;
          ++l;
       }
 
       /* Decrement h while pivot < numbers[h] */
       while (pivot < (*numbers)[h]) {
-        *comparisonCounter++;
-        *memAccessCounter++;
+        *comparisonCounter = *comparisonCounter + 1;
+        *memAccessCounter = *memAccessCounter + 1;
          --h;
       }
 
@@ -73,11 +80,11 @@ int Partition(std::vector<int>* numbers, int i, int k, int *comparisonCounter, i
          /* Swap numbers[l] and numbers[h],
           update l and h */
          temp = (*numbers)[l];
-         *memAccessCounter++;
+         *memAccessCounter = *memAccessCounter + 1;
          (*numbers)[l] = (*numbers)[h];
          *memAccessCounter = *memAccessCounter + 2;
          (*numbers)[h] = temp;
-         *memAccessCounter++;
+         *memAccessCounter = *memAccessCounter + 1;
 
          ++l;
          --h;

quicksort.h

@@ -4,8 +4,16 @@
 // ECS60, UC Davis
 // Adapted from: Lysecky & Vahid "Data Structures Essentials", zyBooks
 
+// include guard
+#ifndef QUICKSORT_H
+#define QUICKSORT_H
+
 #include <vector>
+#include <iostream>
+#include <cstdio>
 
-void QuickSort(std::vector<int>* numbers, int *comparisonCounter, int *memAccessCounter);
+int* QuickSort(std::vector<int>* numbers);
 void QuickSortRecurse(std::vector<int>* numbers, int i, int k, int *comparisonCounter, int *memAccessCounter);
 int Partition(std::vector<int>* numbers, int i, int k, int *comparisonCounter, int *memAccessCounter);
+
+#endif

timealgorithms.cxx

@@ -7,9 +7,9 @@
 #include <vector>
 
 #include "json.hpp"
-//#include "timealgorithms.h"
 #include "insertionsort.h"
 #include "mergesort.h"
+#include "quicksort.h"
 
 int main(int argc, char* argv[]) {
   // read JSON file and store in jsonObject
@@ -25,9 +25,6 @@ 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 *insReturnArray;
   double insStartTime;
@@ -36,11 +33,10 @@ int main(int argc, char* argv[]) {
   int *mergeReturnArray;
   double merStartTime;
   double merTime;
-  //double merTime;
   // initialize quick sort variables
-  //int quickComparisonCounter;
-  //int quickMemAccessCounter;
-  //double quickTime;
+  int *quickReturnArray;
+  double quickStartTime;
+  double quickTime;
 
   std::string sampleName;     // Sample key name to iterate
 
@@ -74,21 +70,23 @@ int main(int argc, char* argv[]) {
   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);
-
-
-  // initiate CSV file to which data will be written
+  std::cout << "merge sort comparison counter: " << *mergeReturnArray << std::endl;
+  std::cout << "merge sort memory access counter: " << *(mergeReturnArray + 1) << std::endl;
+  std::cout << "wallclock time for merge sort: " << merTime << std::endl;
+
+  quickStartTime = time(0);
+  quickReturnArray = QuickSort(sampleArray);
+  quickTime = time(0) - quickStartTime;
+  std::cout << "quick sort comparison counter: " << *quickReturnArray << std::endl;
+  std::cout << "quick sort memory access counter: " << *(quickReturnArray + 1) << std::endl;
+  std::cout << "wallclock time for quick sort: " << quickTime << std::endl;
+
+  // initiate CSV file quickto 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();
+  file.close(); // close JSON file
   return 0;
 }