added Vector::sort using quickSort and changed signature of sorting functions to accept an optional function pointer to be used during comparison && implemented heap sort :)

Author: jumbuna

.DS_Store

@@ -5,12 +5,14 @@
 
 namespace jumbuna {
 template<class T>
-void bubbleSort(T *array, size_t arraySize) {
+void bubbleSort(T *array, size_t arraySize, bool (*function) (T, T) = [](T i, T j) {
+	return i > j;
+}) {
 	bool swapped = false;
 	for(size_t i = 0; i < arraySize; i++) {
 		for(size_t j = 0; j < arraySize-i; j++) {
 			if(j+1 < arraySize) {
-				if(array[j] > array[j+1]) {
+				if(function(array[j], array[j+1])) {
 					T temp = array[j];
 					array[j] = array[j+1];
 					array[j+1] = temp;

algs/.DS_Store

@@ -0,0 +1,47 @@
+#pragma once
+#include <algorithm>
+
+namespace jumbuna {
+template<class T>
+void swap(T *array, int i, int j) {
+	T temp = array[i];
+	array[i] = array[j];
+	array[j] = temp;
+}
+
+template<class T>
+void heapify(T *array, int arraySize, int root, bool (*function) (T, T)) {
+	//move small root value away from index 0
+	int largest = root;
+	int leftChild = 2*root+1;
+	int rightChild = 2*root+2;
+	if(leftChild < arraySize && function(array[leftChild], array[largest])) {
+		largest = leftChild;
+	}
+	if(rightChild < arraySize && function(array[rightChild], array[largest])) {
+		largest = rightChild;
+	}
+	if(largest != root) {
+		swap(array, largest, root);
+		heapify(array, arraySize, largest, function);
+	}
+}
+
+template<class T>
+void heapSort(T *array, int size, bool (*function) (T, T) = [](T i, T j) {
+	return i > j;
+}) {
+	//build initial max heap
+	//size/2-1 = index of last non-leaf node
+	for(int i =size/2-1; i >= 0; i--) {
+		heapify(array, size, i, function);
+	}
+	//reduce size of heap by 1 before every loop
+	for(int i = size-1; i >= 0; i--) {
+		//root which is now the largest element is 'removed' from the heap
+		swap(array, 0, i);
+		heapify(array, i, 0, function);
+	}
+}
+
+}

algs/sorting/BubbleSort.h

@@ -5,17 +5,21 @@
 //constant space complexity
 namespace jumbuna {
 template<class T>
-void insertionSort(T *array, size_t arraySize) {
+void insertionSort(T *array, size_t arraySize, bool (*function) (T, T) = [](T i, T j) {
+	return i > j;
+}) {
 	for(int i = 1; i < arraySize; i++) {
-		if(array[0] > array[i]) {
+		if(function(array[0], array[i])) {
 			T temp = array[i];
 			std::memmove(array+1, array, sizeof(T)*i);
 			array[0] = temp;
 		}else {
 			int newPosition = i;
 			for(int j = i-1; j > 0; j--) {
-				if(array[j] > array[i]) {
+				if(function(array[j], array[i])) {
 					newPosition = j;
+				}else {
+					break;
 				}
 			}
 			if(newPosition != i) {

algs/sorting/HeapSort.h

@@ -6,20 +6,22 @@
 
 namespace jumbuna {
 template<class T>
-void quickSort(T *array, int start, int end) {
+void quickSort(T *array, int start, int end,  bool (*function) (T, T) = [](T i, T j) {
+	return i > j;
+}) {
 	if(start < end) {
 		int pivot = end;
 		for(int i=end-1; i >= start; i--) {
-			if(array[i] > array[pivot]) {
+			if(function(array[i], array[pivot])) {
 				T temp = array[i];
 				array[i] = array[pivot-1];
 				array[pivot-1] = array[pivot];
 				array[pivot] = temp;
 				pivot = pivot-1;
 			}
 		}
-		quickSort(array, start, pivot-1);
-		quickSort(array, pivot+1, end);
+		quickSort(array, start, pivot-1, function);
+		quickSort(array, pivot+1, end, function);
 	}
 }
 }

algs/sorting/InsertionSort.h

@@ -5,11 +5,13 @@
 
 namespace jumbuna {
 template<class T>
-void selectionSort(T *array, size_t arraySize) {
+void selectionSort(T *array, size_t arraySize, bool (*function) (T, T) = [](T i, T j) {
+	return i > j;
+}) {
 	for(size_t i = 0; i < arraySize; i++) {
 		size_t min = i;
-		for(size_t j = i; j < arraySize; j++) {
-			if(array[min] > array[j]) {
+		for(size_t j = i+1; j < arraySize; j++) {
+			if(function(array[min], array[j])) {
 				min = j;
 			}
 		}

algs/sorting/QuickSort.h

@@ -5,7 +5,7 @@
 
 namespace jumbuna {
 template<class T>
-void merge(T *array, size_t lsaStart, size_t lsaEnd, size_t rsaEnd) {	
+void merge(T *array, size_t lsaStart, size_t lsaEnd, size_t rsaEnd,  bool (*function) (T, T)) {	
 	int ll = lsaEnd-lsaStart+1; //size of left subarray
 	int rl = rsaEnd-lsaEnd; // size of right subarray
 
@@ -24,7 +24,7 @@ void merge(T *array, size_t lsaStart, size_t lsaEnd, size_t rsaEnd) {
 	//r - right subarray index
 	int b = lsaStart, l = 0, r = 0;
 	while(l < ll && r < rl) {
-		if(lsa[l] <= rsa[r]) {
+		if(!function(lsa[l], rsa[r])) {
 			array[b] = lsa[l];
 			++l;
 		}else {
@@ -47,12 +47,14 @@ void merge(T *array, size_t lsaStart, size_t lsaEnd, size_t rsaEnd) {
 }
 
 template<class T>
-void mergeSort(T *array, size_t start, size_t end) {
+void mergeSort(T *array, size_t start, size_t end, bool (*function) (T, T) = [](T i, T j) {
+	return i >= j;
+}) {
 	if(start < end) {
 		int midian = start+(end - start)/2;
-		mergeSort(array, start, midian);
-		mergeSort(array, midian+1, end);
-		merge(array, start, midian, end);
+		mergeSort(array, start, midian, function);
+		mergeSort(array, midian+1, end, function);
+		merge(array, start, midian, end, function);
 	}
 }
 }

algs/sorting/SelectionSort.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "PoolAllocator.h"
+#include "../algs/sorting/QuickSort.h"
 
 namespace jumbuna {
 //the passed allocator is actually not used for now
@@ -45,6 +46,8 @@ class Vector {
 	std::size_t size();
 	//get the current capacity of the vector
 	std::size_t currentCapacity();
+	//sort the array
+	void sort();
 	//TODO implement iterators for traversal using specialized for loop
 };
 }

algs/sorting/mergeSort.h

@@ -160,4 +160,9 @@ template<class T, class A>
 std::size_t Vector<T, A>::currentCapacity() {
 	//get current capacity
 	return capacity;
+}
+
+template<class T, class A>
+void Vector<T, A>::sort() {
+	jumbuna::quickSort(memoryPool->poolAddress, 0, currentIndex-1);
 }

ds/Vector.h

@@ -6,23 +6,23 @@ using namespace jumbuna;
 int main() {
 	Vector<int> vector{4};
 	vector.push_back(10);
-	vector.push_back(20);
+	vector.push_back(0);
 	vector.push_back(30);
-	vector.push_back(40);
-	vector.push_back(50);
-	vector.push_back(60);
-	vector.push_back(70);
+	vector.push_back(99);
+	vector.push_back(55);
+	vector.push_back(86);
+	vector.push_back(77);
 	vector.push_back(80);
 	vector.push_back(90);
-	vector.push_back(100);
-	vector.push_back(900);
-	vector.push_back(6600);
-	vector.push_back(18700);
-	vector.push_back(10970);
+	vector.push_back(1);
+	vector.push_back(9);
+	vector.push_back(600);
+	vector.push_back(800);
+	vector.push_back(7);
+	
+	vector.sort();
 
 	for(int i = 0; i < vector.size(); i++) {
 		std::cout << vector[i] << std::endl;
 	}
-	
-	std::cout << vector.currentCapacity();
 }

ds/VectorImpl.h

@@ -4,18 +4,26 @@
 #include "../algs/sorting/InsertionSort.h"
 #include "../algs/sorting/MergeSort.h"
 #include "../algs/sorting/QuickSort.h"
+#include "../algs/sorting/HeapSort.h"
 #include <string>
 
+template<class T>
+bool compare(T i, T j) {
+	//descending order
+	return i < j;
+}
+
 int main(int argc, char *argv[]) {
 	char array[26] = {'r', 'c', 'u', 'v', 'b', 'm', 'o', 'z', 'p', 'w', 'e', 'f', 't', 'i', 'a', 'y', 's', 'd', 'g', 'h', 'j', 'l', 'n', 'q', 'k', 'x'};
 //	for(int i = 1; i < argc; i++) {
 //		array[i-1] = std::stoi(std::string(argv[i]));
 //	}
-//	jumbuna::selectionSort(array, 11);
-//	jumbuna::bubbleSort(array, 11);
-//	jumbuna::insertionSort(array, 11);
-//	jumbuna::mergeSort(array, 0, 25);
-	jumbuna::quickSort(array, 0, 25);
+//	jumbuna::selectionSort(array, 5, ::compare);
+//	jumbuna::bubbleSort(array, 5, ::compare);
+//	jumbuna::insertionSort(array, 5, ::compare);
+//	jumbuna::mergeSort(array, 0, 25, ::compare);
+//	jumbuna::quickSort(array, 0, 25, ::compare);
+	jumbuna::heapSort(array, 26, ::compare);
 	for(int i = 0; i < 26; i++) {
 		std::cout << array[i] << ", ";
 	}