From e64de09c8423d81db47f869f060d0dbda79cc7fb Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Mon, 21 Apr 2025 23:20:02 -0700
Subject: [PATCH 01/27] saving work

---
 bflibcpp/src/array.hpp  | 228 ++++++++++++++++++++++++++++++++++++++--
 bflibcpp/src/list.hpp   |  85 +++++++++++++++
 bflibcpp/src/string.cpp |   4 -
 bflibcpp/src/string.hpp |  13 ++-
 bflibcpp/src/vector.hpp |  20 +---
 bflibcpp/todo.md        |   2 +
 6 files changed, 318 insertions(+), 34 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index df20bf19..d5a7e6ac 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -382,12 +382,6 @@ class Array : public Vector<T,S> {
 
 public:
 
-	/*
-	T operator[](S index) const {
-		return this->objectAtIndex(index);
-	}
-	*/
-
 	void operator=(const std::initializer_list<T> & list) {
 		this->saveArray(list);
 	}
@@ -400,6 +394,14 @@ class Array : public Vector<T,S> {
 		return *this;
 	}
 
+	virtual T operator[](S index) const {
+		return this->objectAtIndex(index);
+	}
+
+	virtual T & operator[](S index) {
+		return this->refObjectAtIndex(index);
+	}
+
 // Comparators
 public:
 	/**
@@ -414,6 +416,220 @@ class Array : public Vector<T,S> {
 			return 0;
 		}
 	}
+
+public:
+
+	/**
+	 * sorts the vector in ascending order
+	 *
+	 * default algorithm is merge sort
+	 */
+	virtual int sort(VectorSort type = kVectorSortMerge) {
+		switch (type) {
+			case kVectorSortBubble:
+				return Array::sortBubble(*this);
+			case kVectorSortInsertion:
+				return Array::sortInsertion(*this);
+			case kVectorSortSelection:
+				return Array::sortSelection(*this);
+			case kVectorSortQuick:
+				return Array::sortQuick(*this);
+			case kVectorSortMerge:
+			default:
+				return Array::sortMerge(*this);
+		}
+	}
+
+private:
+	
+	/** BUBBLE SORT - START **/
+
+	static int sortBubble(Array & c) {
+		int n = c.size();
+		bool swapped;
+
+		for (int i = 0; i < n - 1; i++) {
+			swapped = false;
+			for (int j = 0; j < n - i - 1; j++) {
+				if (c[j] > c[j + 1]) {
+					BFSwap(c[j], c[j + 1]);
+					swapped = true;
+				}
+			}
+
+			// If no two elements were swapped, then break
+			if (!swapped)
+				break;
+		}
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	static int sortInsertion(Array & c) {
+		int i, j;
+		T key;
+		int n = c.size();
+		for (i = 1; i < n; i++) {
+			key = c[i];
+			j = i - 1;
+	 
+			// Move elements of arr[0..i-1],
+			// that are greater than key, to one
+			// position ahead of their
+			// current position
+			while (j >= 0 && c[j] > key) {
+				c[j + 1] = c[j];
+				j = j - 1;
+			}
+			c[j + 1] = key;
+		}
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	static int sortSelection(Array & c) {
+		int i, j, min_idx;
+		int n = c.size();
+
+		// One by one move boundary of
+		// unsorted subarray
+		for (i = 0; i < n-1; i++) {
+			// Find the minimum element in
+			// unsorted array
+			min_idx = i;
+			for (j = i+1; j < n; j++)
+				if (c[j] < c[min_idx])
+					min_idx = j;
+
+			// Swap the found minimum element
+			// with the first element
+			if (c[min_idx] != c[i]) {
+				BFSwap(c[min_idx], c[i]);
+			}
+		}
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	static int sortQuick(Array & c) {
+		return sortQuick(c, 0, c.size() - 1);
+	}
+
+	static int sortQuick(Array & c, int low, int high) {
+		if (low < high) {
+			// pi is the partition return index of pivot
+			int pi = sortQuickPartition(c, low, high);
+
+			// Recursion calls for smaller elements
+			// and greater or equals elements
+			sortQuick(c, low, pi - 1);
+			sortQuick(c, pi + 1, high);
+		}
+
+		return 0;
+	}
+
+	static int sortQuickPartition(Array & c, int low, int high) {
+		// Choose the pivot
+		T pivot = c[high];
+	  
+		// Index of smaller element and indicates 
+		// the right position of pivot found so far
+		int i = low - 1;
+
+		// Traverse arr[;ow..high] and move all smaller
+		// elements on left side. Elements from low to 
+		// i are smaller after every iteration
+		for (int j = low; j <= high - 1; j++) {
+			if (c[j] < pivot) {
+				i++;
+				if (c[i] != c[j]) {
+					BFSwap(c[i], c[j]);
+				}
+			}
+		}
+		
+		// Move pivot after smaller elements and
+		// return its position
+		if (c[i + 1] != c[high]) {
+			BFSwap(c[i + 1], c[high]);
+		}
+		return i + 1;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	static int sortMerge(Array & c) {
+		return sortMerge(c, 0, c.size() - 1);
+	}
+
+	static int sortMerge(Array & c, S left, S right) {
+		if (left >= right)
+			return 0;
+
+		S mid = left + (right - left) / 2;
+		sortMerge(c, left, mid);
+		sortMerge(c, mid + 1, right);
+		sortMerge(c, left, mid, right);
+		return 0;
+	}
+
+	static int sortMerge(Array & c, S left, S mid, S right) {
+		int n1 = mid - left + 1;
+		int n2 = right - mid;
+
+		// Create temp vectors
+		int L[n1], R[n2];
+
+		// Copy data to temp vectors L[] and R[]
+		for (int i = 0; i < n1; i++)
+			L[i] = c[left + i];
+		for (int j = 0; j < n2; j++)
+			R[j] = c[mid + 1 + j];
+
+		int i = 0, j = 0;
+		int k = left;
+
+		// Merge the temp vectors back
+		// into arr[left..right]
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				c[k] = L[i];
+				i++;
+			}
+			else {
+				c[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		// Copy the remaining elements of L[],
+		// if there are any
+		while (i < n1) {
+			c[k] = L[i];
+			i++;
+			k++;
+		}
+
+		// Copy the remaining elements of R[],
+		// if there are any
+		while (j < n2) {
+			c[k] = R[j];
+			j++;
+			k++;
+		}
+		return 0;
+	}
+	
+	/** MERGE SORT - END **/
 };
 
 } // namespace BF
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 86eefe81..483f5355 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -484,6 +484,14 @@ class List : public Vector<L,S> {
 		this->set(list);
 	}
 
+	virtual L operator[](S index) const {
+		return this->objectAtIndex(index);
+	}
+
+	virtual L & operator[](S index) {
+		return this->refObjectAtIndex(index);
+	}
+
 public:
 
 	/**
@@ -520,6 +528,83 @@ class List : public Vector<L,S> {
 	/// required interfaces: begin() & end()
 	Iterator begin() const { return this->first(); }
 	Iterator end() const { return NULL; }
+
+public:
+
+	/**
+	 * sorts the vector in ascending order
+	 *
+	 * default algorithm is merge sort
+	 */
+	virtual int sort(VectorSort type = kVectorSortMerge) {
+		switch (type) {
+			case kVectorSortBubble:
+				return List::sortBubble(*this);
+			case kVectorSortInsertion:
+				return List::sortInsertion(*this);
+			case kVectorSortSelection:
+				return List::sortSelection(*this);
+			case kVectorSortQuick:
+				return List::sortQuick(*this);
+			case kVectorSortMerge:
+			default:
+				return List::sortMerge(*this);
+		}
+	}
+
+private:
+	
+	/** BUBBLE SORT - START **/
+
+	static int sortBubble(List & c) {
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	static int sortInsertion(List & c) {
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	static int sortSelection(List & c) {
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	static int sortQuick(List & c) {
+		return sortQuick(c, 0, c.size() - 1);
+	}
+
+	static int sortQuick(List & c, int low, int high) {
+		return 0;
+	}
+
+	static int sortQuickPartition(List & c, int low, int high) {
+		return 0;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	static int sortMerge(List & c) {
+		return sortMerge(c, 0, c.size() - 1);
+	}
+
+	static int sortMerge(List & c, S left, S right) {
+		return 0;
+	}
+
+	static int sortMerge(List & c, S left, S mid, S right) {
+		return 0;
+	}
+	
+	/** MERGE SORT - END **/
 };
 
 } // namespace BF
diff --git a/bflibcpp/src/string.cpp b/bflibcpp/src/string.cpp
index 886ae2d4..6056b840 100644
--- a/bflibcpp/src/string.cpp
+++ b/bflibcpp/src/string.cpp
@@ -212,10 +212,6 @@ String & String::operator=(const String & str) {
 	return *this;
 }
 
-const char String::operator[](size_t index) const {
-	return this->objectAtIndex(index);
-}
-
 int String::toi(const String & s) {
 	return atoi(s.cString());
 }
diff --git a/bflibcpp/src/string.hpp b/bflibcpp/src/string.hpp
index 8ac7d39b..34a9b478 100644
--- a/bflibcpp/src/string.hpp
+++ b/bflibcpp/src/string.hpp
@@ -132,14 +132,13 @@ class String : public Array<char, size_t> {
 		return out << s.cString();
 	}
 
-	bool operator==(const String & s) const;
-	bool operator==(const char * s) const;
-	bool operator<(const String & s) const;
-	bool operator>(const String & s) const;
-	bool operator!=(const String & s) const;
-	bool operator!=(const char * s) const;
+	virtual bool operator==(const String & s) const;
+	virtual bool operator==(const char * s) const;
+	virtual bool operator<(const String & s) const;
+	virtual bool operator>(const String & s) const;
+	virtual bool operator!=(const String & s) const;
+	virtual bool operator!=(const char * s) const;
 	virtual String & operator=(const String & str);
-	const char operator[](size_t index) const;
 
 // Conversions
 public:
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 90fad20d..87ab5f61 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -37,11 +37,11 @@ class Vector : public Collection<S> {
 	virtual T & refObjectAtIndex(S index) = 0;
 	virtual T max() const = 0;
 
-	T operator[](S index) const {
+	virtual T operator[](S index) const {
 		return this->objectAtIndex(index);
 	}
 
-	T & operator[](S index) {
+	virtual T & operator[](S index) {
 		return this->refObjectAtIndex(index);
 	}
 
@@ -50,21 +50,7 @@ class Vector : public Collection<S> {
 	 *
 	 * default algorithm is merge sort
 	 */
-	int sort(VectorSort type = kVectorSortMerge) {
-		switch (type) {
-			case kVectorSortBubble:
-				return Vector::sortBubble(*this);
-			case kVectorSortInsertion:
-				return Vector::sortInsertion(*this);
-			case kVectorSortSelection:
-				return Vector::sortSelection(*this);
-			case kVectorSortQuick:
-				return Vector::sortQuick(*this);
-			case kVectorSortMerge:
-			default:
-				return Vector::sortMerge(*this);
-		}
-	}
+	virtual int sort(VectorSort type = kVectorSortMerge) = 0;
 
 protected:
 	Vector() : Collection<S>() { }
diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index ec8578cf..0e7c9a1c 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -1,6 +1,8 @@
 
 - [ ] BF::Array to use new/delete for memory allocation
 - [ ] improve List sorting
+	- [ ] move sort logic to array and list
+	- [ ] reevaluate logic location
 - [ ] Vectors to sort strings
 - [x] String append
 - [x] fix leaks in (RBTree specifically) - replaced with map

From dceff3fb696c4a1688c92f0fb832df7be9b0f5e5 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Tue, 22 Apr 2025 22:09:33 -0700
Subject: [PATCH 02/27] Swap

---
 bflibcpp/src/array.hpp  | 23 ++++++++++++-----------
 bflibcpp/src/string.cpp | 10 +++++++++-
 bflibcpp/src/string.hpp |  2 ++
 bflibcpp/src/swap.hpp   | 21 +++++++++++++++++++++
 4 files changed, 44 insertions(+), 12 deletions(-)
 create mode 100644 bflibcpp/src/swap.hpp

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index d5a7e6ac..921f096c 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -14,6 +14,7 @@
 #include "vector.hpp"
 #include <string.h>
 #include "exception.hpp"
+#include "swap.hpp"
 
 namespace BF {
 
@@ -452,7 +453,7 @@ class Array : public Vector<T,S> {
 			swapped = false;
 			for (int j = 0; j < n - i - 1; j++) {
 				if (c[j] > c[j + 1]) {
-					BFSwap(c[j], c[j + 1]);
+					swap(c[j], c[j + 1]);
 					swapped = true;
 				}
 			}
@@ -508,7 +509,7 @@ class Array : public Vector<T,S> {
 			// Swap the found minimum element
 			// with the first element
 			if (c[min_idx] != c[i]) {
-				BFSwap(c[min_idx], c[i]);
+				swap(c[min_idx], c[i]);
 			}
 		}
 		return 0;
@@ -550,7 +551,7 @@ class Array : public Vector<T,S> {
 			if (c[j] < pivot) {
 				i++;
 				if (c[i] != c[j]) {
-					BFSwap(c[i], c[j]);
+					swap(c[i], c[j]);
 				}
 			}
 		}
@@ -558,7 +559,7 @@ class Array : public Vector<T,S> {
 		// Move pivot after smaller elements and
 		// return its position
 		if (c[i + 1] != c[high]) {
-			BFSwap(c[i + 1], c[high]);
+			swap(c[i + 1], c[high]);
 		}
 		return i + 1;
 	}
@@ -582,20 +583,20 @@ class Array : public Vector<T,S> {
 	}
 
 	static int sortMerge(Array & c, S left, S mid, S right) {
-		int n1 = mid - left + 1;
-		int n2 = right - mid;
+		S n1 = mid - left + 1;
+		S n2 = right - mid;
 
 		// Create temp vectors
-		int L[n1], R[n2];
+		T L[n1], R[n2];
 
 		// Copy data to temp vectors L[] and R[]
-		for (int i = 0; i < n1; i++)
+		for (S i = 0; i < n1; i++)
 			L[i] = c[left + i];
-		for (int j = 0; j < n2; j++)
+		for (S j = 0; j < n2; j++)
 			R[j] = c[mid + 1 + j];
 
-		int i = 0, j = 0;
-		int k = left;
+		S i = 0, j = 0;
+		S k = left;
 
 		// Merge the temp vectors back
 		// into arr[left..right]
diff --git a/bflibcpp/src/string.cpp b/bflibcpp/src/string.cpp
index 6056b840..45c58b0a 100644
--- a/bflibcpp/src/string.cpp
+++ b/bflibcpp/src/string.cpp
@@ -182,8 +182,16 @@ bool String::operator<(const String & s) const {
 	return this->compareString(s) < 0;
 }
 
+bool String::operator<=(const String & s) const {
+	return this->compareString(s) <= 0;
+}
+
 bool String::operator>(const String & s) const {
-	return this->compareString(s) >0;
+	return this->compareString(s) > 0;
+}
+
+bool String::operator>=(const String & s) const {
+	return this->compareString(s) >= 0;
 }
 
 int String::compareString(const String & s) const {
diff --git a/bflibcpp/src/string.hpp b/bflibcpp/src/string.hpp
index 34a9b478..3f5689d5 100644
--- a/bflibcpp/src/string.hpp
+++ b/bflibcpp/src/string.hpp
@@ -135,7 +135,9 @@ class String : public Array<char, size_t> {
 	virtual bool operator==(const String & s) const;
 	virtual bool operator==(const char * s) const;
 	virtual bool operator<(const String & s) const;
+	virtual bool operator<=(const String & s) const;
 	virtual bool operator>(const String & s) const;
+	virtual bool operator>=(const String & s) const;
 	virtual bool operator!=(const String & s) const;
 	virtual bool operator!=(const char * s) const;
 	virtual String & operator=(const String & str);
diff --git a/bflibcpp/src/swap.hpp b/bflibcpp/src/swap.hpp
new file mode 100644
index 00000000..a06c76df
--- /dev/null
+++ b/bflibcpp/src/swap.hpp
@@ -0,0 +1,21 @@
+/**
+ * author: brando
+ * date: 4/22/25
+ */
+
+#ifndef SWAP_HPP
+#define SWAP_HPP
+
+namespace BF {
+
+template<typename T>
+void swap(T & a, T & b) {
+	T tmp = a;
+	a = b;
+	b = tmp;
+}
+
+}
+
+#endif // SWAP_HPP
+

From 8085fdffaf730a6d5bea0dc25c327ed14d998bea Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Tue, 22 Apr 2025 22:24:36 -0700
Subject: [PATCH 03/27] bubble sort

---
 bflibcpp/src/list.hpp        | 40 ++++++++++++++++++++++++++++++++++++
 bflibcpp/testbench/tests.cpp |  6 ++++++
 2 files changed, 46 insertions(+)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 483f5355..7984f3cc 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -557,6 +557,46 @@ class List : public Vector<L,S> {
 	/** BUBBLE SORT - START **/
 
 	static int sortBubble(List & c) {
+		Node * head = c.first();
+		S len = c.size();
+		int itr = 0;
+		bool swapped = false;
+
+		while (itr < len) {
+			Node * trav = head;
+			Node * prev = head;
+			swapped = false;
+			
+			while (trav->next()) {
+				Node * ptr = trav->next();
+				if (trav->object() > ptr->object()) {
+					swapped = true;
+					if (trav == head) {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev = ptr;
+						head = prev;
+					} else {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev->right = ptr;
+						prev = ptr;
+					}
+
+					continue;
+				}
+				prev = trav;
+				trav = trav->next();
+			}
+
+			if (!swapped) {
+				break;
+			}
+			++itr;
+		}
+
+		c._head = head;
+
 		return 0;
 	}
 
diff --git a/bflibcpp/testbench/tests.cpp b/bflibcpp/testbench/tests.cpp
index 77ef3eac..cdd8c36f 100644
--- a/bflibcpp/testbench/tests.cpp
+++ b/bflibcpp/testbench/tests.cpp
@@ -22,6 +22,7 @@
 #include "defer_tests.hpp"
 
 BFTEST_SUITE_FUNC({
+	/*
 	BFTEST_SUITE_LAUNCH(atomic_tests);
 	BFTEST_SUITE_LAUNCH(string_tests);
 	BFTEST_SUITE_LAUNCH(stack_tests);
@@ -29,14 +30,19 @@ BFTEST_SUITE_FUNC({
 	BFTEST_SUITE_LAUNCH(time_tests);
 	BFTEST_SUITE_LAUNCH(data_tests);
 	BFTEST_SUITE_LAUNCH(array_tests);
+	*/
 	BFTEST_SUITE_LAUNCH(vector_tests);
+	/*
 	BFTEST_SUITE_LAUNCH(map_tests);
 	BFTEST_SUITE_LAUNCH(object_tests);
+	*/
 	BFTEST_SUITE_LAUNCH(list_tests);
+	/*
 	BFTEST_SUITE_LAUNCH(hashmap_tests);
 	BFTEST_SUITE_LAUNCH(exception_tests);
 	BFTEST_SUITE_LAUNCH(tree_tests);
 	BFTEST_SUITE_LAUNCH(url_tests);
 	BFTEST_SUITE_LAUNCH(defer_tests);
+	*/
 })
 

From b1c71c5fe26afa5b7820d16b80b60a20985f3e7d Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 07:14:57 -0700
Subject: [PATCH 04/27] insertion sort

---
 bflibcpp/src/list.hpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 7984f3cc..4823306d 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -603,7 +603,36 @@ class List : public Vector<L,S> {
 	/** BUBBLE SORT - END **/
 	/** INSERTION SORT - START **/
 
+	static Node * sortInsertion(Node * newNode, Node * sorted) {
+		if (!sorted || sorted->object() >= newNode->object()) {
+			newNode->right = sorted;
+			sorted = newNode;
+		} else {
+			Node * curr = sorted;
+			while (curr->right && curr->right->object() < newNode->object()) {
+				curr = curr->next();
+			}
+
+			newNode->right = curr->right;
+			curr->right = newNode;
+		}
+
+		return sorted;
+	}
+
 	static int sortInsertion(List & c) {
+		Node * head = c.first();
+		Node * sorted = NULL;
+		Node * curr = head;
+
+		while (curr) {
+			Node * next = curr->next();
+			sorted = sortInsertion(curr, sorted);
+			curr = next;
+		}
+
+		c._head = sorted;
+
 		return 0;
 	}
 

From de003dc3f1168819e97901684ef693b0882bf588 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 07:19:38 -0700
Subject: [PATCH 05/27] selection sort

---
 bflibcpp/src/list.hpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 4823306d..c3c931ed 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -640,6 +640,23 @@ class List : public Vector<L,S> {
 	/** SELECTION SORT - START **/
 
 	static int sortSelection(List & c) {
+		Node * head = c.first();
+		for (Node * start = head; start; start = start->next()) {
+			Node * min = start;
+			for (Node * curr = start->next(); curr; curr = curr->next()) {
+				if (curr->object() < min->object()) {
+					min = curr;
+				}
+			}
+
+			if (min != start) {
+				L val = start->object();
+				start->obj = min->object();
+				min->obj = val;
+			}
+		}
+
+		c._head = head;
 		return 0;
 	}
 

From 1da111269906c706af45e6679ec73da4be97a9cf Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 09:44:19 -0700
Subject: [PATCH 06/27] quick sort

---
 bflibcpp/src/list.hpp | 40 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 5 deletions(-)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index c3c931ed..6a2a24b7 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -9,6 +9,7 @@
 #include "access.hpp"
 #include "vector.hpp"
 #include "exception.hpp"
+#include "swap.hpp"
 #include <iostream>
 #include <initializer_list>
 
@@ -664,15 +665,44 @@ class List : public Vector<L,S> {
 	/** QUICK SORT - START **/
 
 	static int sortQuick(List & c) {
-		return sortQuick(c, 0, c.size() - 1);
-	}
+		Node * head = c.first();
+		Node * tail = c.last();
+
+		sortQuick(head, tail);
 
-	static int sortQuick(List & c, int low, int high) {
+		c._head = head;
 		return 0;
 	}
+	
+	static void sortQuick(Node * head, Node * tail) {
+		if (!head || head == tail) {
+			return;
+		}
 
-	static int sortQuickPartition(List & c, int low, int high) {
-		return 0;
+		Node * pivot = sortQuickGetPivot(head, tail);
+
+		sortQuick(head, pivot);
+		sortQuick(pivot->next(), tail);
+	}
+	
+	static Node * sortQuickGetPivot(Node * head, Node * tail) {
+		Node * pivot = head;
+
+		Node * pre = head;
+		Node * curr = head;
+
+		while (curr != tail->next()) {
+			if (curr->object() < pivot->object()) {
+				BF::swap<L>(curr->obj, pre->right->obj);
+				pre = pre->next();
+			}
+
+			curr = curr->next();
+		}
+
+		BF::swap<L>(pivot->obj, pre->obj);
+
+		return pre;
 	}
 
 	/** QUICK SORT - END **/

From 3d7cc765f5adf4f06a8fa1cff18728e2d32d8f52 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 10:01:46 -0700
Subject: [PATCH 07/27] good sorting algorithms

---
 bflibcpp/src/list.hpp               | 44 +++++++++++++++++++++++++----
 bflibcpp/testbench/vector_tests.hpp | 14 ++++-----
 2 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 6a2a24b7..cdd2a9a7 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -709,15 +709,49 @@ class List : public Vector<L,S> {
 	/** MERGE SORT - START **/
 
 	static int sortMerge(List & c) {
-		return sortMerge(c, 0, c.size() - 1);
+		c._head = sortMerge(c._head);
+		return 0;
 	}
 
-	static int sortMerge(List & c, S left, S right) {
-		return 0;
+	static Node * sortMerge(Node * head) {
+		if (!head || !head->next()) {
+			return head;
+		}
+
+		Node * second = sortMergeSplit(head);
+		head = sortMerge(head);
+		second = sortMerge(second);
+
+		return sortMerge(head, second);
 	}
+	
+	static Node * sortMerge(Node * first, Node * second) {
+		if (!first) return second;
+		if (!second) return first;
 
-	static int sortMerge(List & c, S left, S mid, S right) {
-		return 0;
+		if (first->object() < second->object()) {
+			first->right = sortMerge(first->next(), second);
+			return first;
+		} else {
+			second->right = sortMerge(first, second->next());
+			return second;
+		}
+	}
+
+	static Node * sortMergeSplit(Node * head) {
+		Node * fast = head;
+		Node * slow = head;
+
+		while (fast && fast->next()) {
+			fast = fast->right->right;
+			if (fast) {
+				slow = slow->right;
+			}
+		}
+
+		Node * tmp = slow->right;
+		slow->right = NULL;
+		return tmp;
 	}
 	
 	/** MERGE SORT - END **/
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 5985dadd..05abdd60 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -67,7 +67,7 @@ BFTEST_UNIT_FUNC(test_vectorListSortBubble, 1,  {
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortInsertion, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortInsertion, 2 << 10, 1);
+	int err = run_vectorSort<List<int>>(kVectorSortInsertion, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
@@ -82,32 +82,32 @@ BFTEST_UNIT_FUNC(test_vectorListSortQuick, 1,  {
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortMerge, 1, {
-	int err = run_vectorSort<List<int>>(kVectorSortMerge, 2 << 12, 1);
+	int err = run_vectorSort<List<int>>(kVectorSortMerge, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortBubble, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortBubble, 2 << 12, 4);
+	int err = run_vectorSort<Array<int>>(kVectorSortBubble, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortInsertion, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortInsertion, 2 << 13, 4);
+	int err = run_vectorSort<Array<int>>(kVectorSortInsertion, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortSelection, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortSelection, 2 << 13, 4);
+	int err = run_vectorSort<Array<int>>(kVectorSortSelection, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortQuick, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortQuick, 2 << 13, 4);
+	int err = run_vectorSort<Array<int>>(kVectorSortQuick, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortMerge, 2 << 12, 4);
+	int err = run_vectorSort<Array<int>>(kVectorSortMerge, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 

From 88007aa3998a06e8807c8bdc844bbefc8d85dccf Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 13:35:56 -0700
Subject: [PATCH 08/27] cleaning up vec

---
 bflibcpp/src/list.hpp             |  17 +--
 bflibcpp/src/sort.hpp             |  18 +++
 bflibcpp/src/vector.hpp           | 190 ------------------------------
 bflibcpp/testbench/list_tests.hpp |  63 +---------
 bflibcpp/testbench/tests.cpp      |   2 +-
 5 files changed, 21 insertions(+), 269 deletions(-)
 create mode 100644 bflibcpp/src/sort.hpp

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index cdd2a9a7..91bd2331 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -278,8 +278,7 @@ class List : public Vector<L,S> {
 			// Get random node
 			int r = rand() % (i + 1);
 			Node * tmp = this->nodeAtIndex(r, this->_head, 0);
-			int err = this->swap(n, tmp); // swap nodes
-			if (err) return err; // leave if there was an error in swapping
+			BF::swap<L>(n->obj, tmp->obj); // swap nodes
 			i--;
 		}
 
@@ -317,20 +316,6 @@ class List : public Vector<L,S> {
 
 private:
 
-	/**
-	 * Swaps a and b objects
-	 */
-	static int swap(Node * a, Node * b) {
-		// Don't continue with this if a or b are null
-		if (!a || !b) return -1;
-		else {
-			L obj = a->obj;
-			a->obj = b->obj;
-			b->obj = obj;
-			return 0;
-		}
-	}
-
 	/**
 	 * Allows us to set list with {...} notation
 	 *
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
new file mode 100644
index 00000000..20a8c7f6
--- /dev/null
+++ b/bflibcpp/src/sort.hpp
@@ -0,0 +1,18 @@
+/**
+ * author: brando
+ * date: 4/23/25
+ */
+
+#ifndef SORT_HPP
+#define SORT_HPP
+
+#include "list.hpp"
+#include "list.hpp"
+
+namespace BF {
+
+template<typename  > struct Sort;
+}
+
+#endif // SORT_HPP
+
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 87ab5f61..13d1ada6 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -54,196 +54,6 @@ class Vector : public Collection<S> {
 
 protected:
 	Vector() : Collection<S>() { }
-
-private:
-	
-	/** BUBBLE SORT - START **/
-
-	static int sortBubble(Vector & c) {
-		int n = c.size();
-		bool swapped;
-
-		for (int i = 0; i < n - 1; i++) {
-			swapped = false;
-			for (int j = 0; j < n - i - 1; j++) {
-				if (c[j] > c[j + 1]) {
-					BFSwap(c[j], c[j + 1]);
-					swapped = true;
-				}
-			}
-
-			// If no two elements were swapped, then break
-			if (!swapped)
-				break;
-		}
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	static int sortInsertion(Vector & c) {
-		int i, key, j;
-		int n = c.size();
-		for (i = 1; i < n; i++) {
-			key = c[i];
-			j = i - 1;
-	 
-			// Move elements of arr[0..i-1],
-			// that are greater than key, to one
-			// position ahead of their
-			// current position
-			while (j >= 0 && c[j] > key) {
-				c[j + 1] = c[j];
-				j = j - 1;
-			}
-			c[j + 1] = key;
-		}
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	static int sortSelection(Vector & c) {
-		int i, j, min_idx;
-		int n = c.size();
-
-		// One by one move boundary of
-		// unsorted subarray
-		for (i = 0; i < n-1; i++) {
-			// Find the minimum element in
-			// unsorted array
-			min_idx = i;
-			for (j = i+1; j < n; j++)
-				if (c[j] < c[min_idx])
-					min_idx = j;
-
-			// Swap the found minimum element
-			// with the first element
-			if (c[min_idx] != c[i]) {
-				BFSwap(c[min_idx], c[i]);
-			}
-		}
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	static int sortQuick(Vector & c) {
-		return sortQuick(c, 0, c.size() - 1);
-	}
-
-	static int sortQuick(Vector & c, int low, int high) {
-		if (low < high) {
-			// pi is the partition return index of pivot
-			int pi = sortQuickPartition(c, low, high);
-
-			// Recursion calls for smaller elements
-			// and greater or equals elements
-			sortQuick(c, low, pi - 1);
-			sortQuick(c, pi + 1, high);
-		}
-
-		return 0;
-	}
-
-	static int sortQuickPartition(Vector & c, int low, int high) {
-		// Choose the pivot
-		int pivot = c[high];
-	  
-		// Index of smaller element and indicates 
-		// the right position of pivot found so far
-		int i = low - 1;
-
-		// Traverse arr[;ow..high] and move all smaller
-		// elements on left side. Elements from low to 
-		// i are smaller after every iteration
-		for (int j = low; j <= high - 1; j++) {
-			if (c[j] < pivot) {
-				i++;
-				if (c[i] != c[j]) {
-					BFSwap(c[i], c[j]);
-				}
-			}
-		}
-		
-		// Move pivot after smaller elements and
-		// return its position
-		if (c[i + 1] != c[high]) {
-			BFSwap(c[i + 1], c[high]);
-		}
-		return i + 1;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	static int sortMerge(Vector & c) {
-		return sortMerge(c, 0, c.size() - 1);
-	}
-
-	static int sortMerge(Vector & c, S left, S right) {
-		if (left >= right)
-			return 0;
-
-		S mid = left + (right - left) / 2;
-		sortMerge(c, left, mid);
-		sortMerge(c, mid + 1, right);
-		sortMerge(c, left, mid, right);
-		return 0;
-	}
-
-	static int sortMerge(Vector & c, S left, S mid, S right) {
-		int n1 = mid - left + 1;
-		int n2 = right - mid;
-
-		// Create temp vectors
-		int L[n1], R[n2];
-
-		// Copy data to temp vectors L[] and R[]
-		for (int i = 0; i < n1; i++)
-			L[i] = c[left + i];
-		for (int j = 0; j < n2; j++)
-			R[j] = c[mid + 1 + j];
-
-		int i = 0, j = 0;
-		int k = left;
-
-		// Merge the temp vectors back
-		// into arr[left..right]
-		while (i < n1 && j < n2) {
-			if (L[i] <= R[j]) {
-				c[k] = L[i];
-				i++;
-			}
-			else {
-				c[k] = R[j];
-				j++;
-			}
-			k++;
-		}
-
-		// Copy the remaining elements of L[],
-		// if there are any
-		while (i < n1) {
-			c[k] = L[i];
-			i++;
-			k++;
-		}
-
-		// Copy the remaining elements of R[],
-		// if there are any
-		while (j < n2) {
-			c[k] = R[j];
-			j++;
-			k++;
-		}
-		return 0;
-	}
-	
-	/** MERGE SORT - END **/
 };
 }
 
diff --git a/bflibcpp/testbench/list_tests.hpp b/bflibcpp/testbench/list_tests.hpp
index f2d84783..15f5fcfb 100644
--- a/bflibcpp/testbench/list_tests.hpp
+++ b/bflibcpp/testbench/list_tests.hpp
@@ -8,7 +8,7 @@
 
 #define ASSERT_PUBLIC_MEMBER_ACCESS
 
-#include <list.hpp>
+#include "list.hpp"
 #include "release.hpp"
 
 extern "C" {
@@ -191,65 +191,6 @@ BFTEST_UNIT_FUNC(test_InitializingFromRawArray, 2<<10, {
 	}
 })
 
-BFTEST_UNIT_FUNC(test_ListNullSwap, 2<<10,  {
-	List<int>::Node a, b;
-	a.obj = 0;
-	b.obj = 1;
-	BF_ASSERT(List<int>::swap(&a, 0) != 0);
-	BF_ASSERT(List<int>::swap(0, &b) != 0);
-	BF_ASSERT(List<int>::swap(0, 0) != 0);
-})
-
-BFTEST_UNIT_FUNC(test_ListSwap, 2<<10, {
-	List<int>::Node * a = new List<int>::Node;
-	a->obj = 1;
-	List<int>::Node * al = new List<int>::Node;
-	List<int>::Node * ar = new List<int>::Node;
-	a->left = al;
-	a->right = ar;
-	al->right = a;
-	ar->left = a;
-
-	List<int>::Node * b = new List<int>::Node;
-	b->obj = 2;
-	List<int>::Node * bl = new List<int>::Node;
-	List<int>::Node * br = new List<int>::Node;
-	b->left = bl;
-	b->right = br;
-	bl->right = b;
-	br->left = b;
-
-	BF_ASSERT(a->obj == 1);
-	BF_ASSERT(a->prev() == al);
-	BF_ASSERT(a->next() == ar);
-	BF_ASSERT(al->next() == a);
-	BF_ASSERT(ar->prev() == a);
-	BF_ASSERT(b->obj == 2);
-	BF_ASSERT(b->prev() == bl);
-	BF_ASSERT(b->next() == br);
-	BF_ASSERT(bl->next() == b);
-	BF_ASSERT(br->prev() == b);
-
-	BF_ASSERT(!List<int>::swap(a, b));
-	BF_ASSERT(a->obj == 2);
-	BF_ASSERT(a->prev() == al);
-	BF_ASSERT(a->next() == ar);
-	BF_ASSERT(al->next() == a);
-	BF_ASSERT(ar->prev() == a);
-	BF_ASSERT(b->obj == 1);
-	BF_ASSERT(b->prev() == bl);
-	BF_ASSERT(b->next() == br);
-	BF_ASSERT(bl->next() == b);
-	BF_ASSERT(br->prev() == b);
-	
-	BFRelease(a);
-	BFRelease(al);
-	BFRelease(ar);
-	BFRelease(b);
-	BFRelease(bl);
-	BFRelease(br);
-})
-
 BFTEST_UNIT_FUNC(test_shuffle, 1,  {
 	const int size = 2 << 14;
 	int array[size];
@@ -414,9 +355,7 @@ BFTEST_COVERAGE_FUNC(list_tests, {
 	BFTEST_LAUNCH(test_ListContains);
 	BFTEST_LAUNCH(test_InitializingWithInitList);
 	BFTEST_LAUNCH(test_InitializingFromRawArray);
-	BFTEST_LAUNCH(test_ListSwap);
 	BFTEST_LAUNCH(test_shuffle);
-	BFTEST_LAUNCH(test_ListNullSwap);
 	BFTEST_LAUNCH(test_ShuffleLargeDataSet);
 	BFTEST_LAUNCH(test_pluckingObject);
 	BFTEST_LAUNCH(test_rangeBasedLooping);
diff --git a/bflibcpp/testbench/tests.cpp b/bflibcpp/testbench/tests.cpp
index cdd8c36f..83e595f5 100644
--- a/bflibcpp/testbench/tests.cpp
+++ b/bflibcpp/testbench/tests.cpp
@@ -29,8 +29,8 @@ BFTEST_SUITE_FUNC({
 	BFTEST_SUITE_LAUNCH(queue_tests);
 	BFTEST_SUITE_LAUNCH(time_tests);
 	BFTEST_SUITE_LAUNCH(data_tests);
-	BFTEST_SUITE_LAUNCH(array_tests);
 	*/
+	BFTEST_SUITE_LAUNCH(array_tests);
 	BFTEST_SUITE_LAUNCH(vector_tests);
 	/*
 	BFTEST_SUITE_LAUNCH(map_tests);

From 2cb99f59951f571d601edda1641643420d73a914 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 13:52:45 -0700
Subject: [PATCH 09/27] can compile

---
 bflibcpp/src/list.hpp |  8 ++++++++
 bflibcpp/src/sort.hpp | 12 ++++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 91bd2331..6ff26d1d 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -10,6 +10,7 @@
 #include "vector.hpp"
 #include "exception.hpp"
 #include "swap.hpp"
+#include "sort.hpp"
 #include <iostream>
 #include <initializer_list>
 
@@ -742,6 +743,13 @@ class List : public Vector<L,S> {
 	/** MERGE SORT - END **/
 };
 
+template <> struct Sort<List> {
+	template <typename L, typename S = size_t> 
+	int operator()(List<L, S> & list) {
+		return 0;
+	}
+};
+
 } // namespace BF
 
 #endif // LIST_HPP
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index 20a8c7f6..04206ce8 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -6,12 +6,20 @@
 #ifndef SORT_HPP
 #define SORT_HPP
 
-#include "list.hpp"
 #include "list.hpp"
 
 namespace BF {
 
-template<typename  > struct Sort;
+typedef enum {
+	kSortStrategyBubble = 1,
+	kSortStrategyInsertion = 2,
+	kSortStrategySelection = 3,
+	kSortStrategyMerge = 4,
+	kSortStrategyQuick = 5,
+} SortStrategy;
+
+template<template <typename...> class T> struct Sort;
+
 }
 
 #endif // SORT_HPP

From c98d5a6da1b6eae943c56a2526e348b1db688868 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 14:23:53 -0700
Subject: [PATCH 10/27] can compile

---
 bflibcpp/src/list.hpp | 227 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 226 insertions(+), 1 deletion(-)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 6ff26d1d..8e24ea3d 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -745,9 +745,234 @@ class List : public Vector<L,S> {
 
 template <> struct Sort<List> {
 	template <typename L, typename S = size_t> 
-	int operator()(List<L, S> & list) {
+	int operator()(List<L,S> & list) {
+		SortStrategy type = kSortStrategyMerge;
+		switch (type) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<L,S>(list);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<L,S>(list);
+			case kSortStrategySelection:
+				return Sort::sortSelection<L,S>(list);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<L,S>(list);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<L,S>(list);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortBubble(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		S len = c.size();
+		int itr = 0;
+		bool swapped = false;
+
+		while (itr < len) {
+			typename List<L,S>::Node * trav = head;
+			typename List<L,S>::Node * prev = head;
+			swapped = false;
+			
+			while (trav->next()) {
+				typename List<L,S>::Node * ptr = trav->next();
+				if (trav->object() > ptr->object()) {
+					swapped = true;
+					if (trav == head) {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev = ptr;
+						head = prev;
+					} else {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev->right = ptr;
+						prev = ptr;
+					}
+
+					continue;
+				}
+				prev = trav;
+				trav = trav->next();
+			}
+
+			if (!swapped) {
+				break;
+			}
+			++itr;
+		}
+
+		c._head = head;
+
 		return 0;
 	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
+		if (!sorted || sorted->object() >= newNode->object()) {
+			newNode->right = sorted;
+			sorted = newNode;
+		} else {
+			typename List<L,S>::Node * curr = sorted;
+			while (curr->right && curr->right->object() < newNode->object()) {
+				curr = curr->next();
+			}
+
+			newNode->right = curr->right;
+			curr->right = newNode;
+		}
+
+		return sorted;
+	}
+
+	template <typename L, typename S = size_t> 
+	static int sortInsertion(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * sorted = NULL;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr) {
+			typename List<L,S>::Node * next = curr->next();
+			sorted = sortInsertion<L,S>(curr, sorted);
+			curr = next;
+		}
+
+		c._head = sorted;
+
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortSelection(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		for (typename List<L,S>::Node * start = head; start; start = start->next()) {
+			typename List<L,S>::Node * min = start;
+			for (typename List<L,S>::Node * curr = start->next(); curr; curr = curr->next()) {
+				if (curr->object() < min->object()) {
+					min = curr;
+				}
+			}
+
+			if (min != start) {
+				L val = start->object();
+				start->obj = min->object();
+				min->obj = val;
+			}
+		}
+
+		c._head = head;
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortQuick(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * tail = c.last();
+
+		sortQuick<L,S>(head, tail);
+
+		c._head = head;
+		return 0;
+	}
+	
+	template <typename L, typename S = size_t> 
+	static void sortQuick(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		if (!head || head == tail) {
+			return;
+		}
+
+		typename List<L,S>::Node * pivot = sortQuickGetPivot<L,S>(head, tail);
+
+		sortQuick<L,S>(head, pivot);
+		sortQuick<L,S>(pivot->next(), tail);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		typename List<L,S>::Node * pivot = head;
+
+		typename List<L,S>::Node * pre = head;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr != tail->next()) {
+			if (curr->object() < pivot->object()) {
+				BF::swap<L>(curr->obj, pre->right->obj);
+				pre = pre->next();
+			}
+
+			curr = curr->next();
+		}
+
+		BF::swap<L>(pivot->obj, pre->obj);
+
+		return pre;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortMerge(List<L,S> & c) {
+		c._head = sortMerge<L,S>(c._head);
+		return 0;
+	}
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
+		if (!head || !head->next()) {
+			return head;
+		}
+
+		typename List<L,S>::Node * second = sortMergeSplit<L,S>(head);
+		head = sortMerge<L,S>(head);
+		second = sortMerge<L,S>(second);
+
+		return sortMerge(head, second);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
+		if (!first) return second;
+		if (!second) return first;
+
+		if (first->object() < second->object()) {
+			first->right = sortMerge<L,S>(first->next(), second);
+			return first;
+		} else {
+			second->right = sortMerge<L,S>(first, second->next());
+			return second;
+		}
+	}
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
+		typename List<L,S>::Node * fast = head;
+		typename List<L,S>::Node * slow = head;
+
+		while (fast && fast->next()) {
+			fast = fast->right->right;
+			if (fast) {
+				slow = slow->right;
+			}
+		}
+
+		typename List<L,S>::Node * tmp = slow->right;
+		slow->right = NULL;
+		return tmp;
+	}
+	
+	/** MERGE SORT - END **/
 };
 
 } // namespace BF

From 9087c350e1002e4783f994bddfb8ac07b6b89fbd Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 14:39:54 -0700
Subject: [PATCH 11/27] can compile

---
 bflibcpp/src/sort.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index 04206ce8..a0cf60fe 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -20,6 +20,12 @@ typedef enum {
 
 template<template <typename...> class T> struct Sort;
 
+// Generic sort function
+template <template <typename...> class ContainerTemplate, typename... Args>
+int sort(ContainerTemplate<Args...>& v) {
+    Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
+    return sorter(v);
+}
 }
 
 #endif // SORT_HPP

From 18bcba357df11bb72c84dc42e28f48b2f9ee6f54 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 14:55:31 -0700
Subject: [PATCH 12/27] Can compile

---
 bflibcpp/src/array.hpp              | 219 ++++++++++++++++++++++++++++
 bflibcpp/src/list.hpp               |   3 +-
 bflibcpp/src/sort.hpp               |   4 +-
 bflibcpp/src/vector.hpp             |   1 +
 bflibcpp/testbench/vector_tests.hpp |  26 ++--
 5 files changed, 236 insertions(+), 17 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index 921f096c..0ff737c9 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -633,6 +633,225 @@ class Array : public Vector<T,S> {
 	/** MERGE SORT - END **/
 };
 
+template <> struct Sort<Array> {
+	template <typename T, typename S = size_t> 
+	int operator()(Array<T,S> & array) {
+		SortStrategy type = kSortStrategyMerge;
+		switch (type) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<T,S>(array);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<T,S>(array);
+			case kSortStrategySelection:
+				return Sort::sortSelection<T,S>(array);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<T,S>(array);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<T,S>(array);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortBubble(Array<T,S> & c) {
+		S n = c.size();
+		bool swapped = false;
+
+		for (S i = 0; i < n - 1; i++) {
+			swapped = false;
+			for (S j = 0; j < n - i - 1; j++) {
+				if (c[j] > c[j + 1]) {
+					swap(c[j], c[j + 1]);
+					swapped = true;
+				}
+			}
+
+			// If no two elements were swapped, then break
+			if (!swapped)
+				break;
+		}
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortInsertion(Array<T,S> & c) {
+		S i, j;
+		T key;
+		S n = c.size();
+		for (i = 1; i < n; i++) {
+			key = c[i];
+			j = i - 1;
+	 
+			// Move elements of arr[0..i-1],
+			// that are greater than key, to one
+			// position ahead of their
+			// current position
+			while (j >= 0 && c[j] > key) {
+				c[j + 1] = c[j];
+				j = j - 1;
+			}
+			c[j + 1] = key;
+		}
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortSelection(Array<T,S> & c) {
+		S i, j, min_idx;
+		S n = c.size();
+
+		// One by one move boundary of
+		// unsorted subarray
+		for (i = 0; i < n-1; i++) {
+			// Find the minimum element in
+			// unsorted array
+			min_idx = i;
+			for (j = i+1; j < n; j++)
+				if (c[j] < c[min_idx])
+					min_idx = j;
+
+			// Swap the found minimum element
+			// with the first element
+			if (c[min_idx] != c[i]) {
+				swap(c[min_idx], c[i]);
+			}
+		}
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c) {
+		return sortQuick<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c, S low, S high) {
+		if (low < high) {
+			// pi is the partition return index of pivot
+			S pi = sortQuickPartition<T,S>(c, low, high);
+
+			// Recursion calls for smaller elements
+			// and greater or equals elements
+			sortQuick<T,S>(c, low, pi - 1);
+			sortQuick<T,S>(c, pi + 1, high);
+		}
+
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuickPartition(Array<T,S> & c, S low, S high) {
+		// Choose the pivot
+		T pivot = c[high];
+	  
+		// Index of smaller element and indicates 
+		// the right position of pivot found so far
+		S i = low - 1;
+
+		// Traverse arr[;ow..high] and move all smaller
+		// elements on left side. Elements from low to 
+		// i are smaller after every iteration
+		for (S j = low; j <= high - 1; j++) {
+			if (c[j] < pivot) {
+				i++;
+				if (c[i] != c[j]) {
+					swap(c[i], c[j]);
+				}
+			}
+		}
+		
+		// Move pivot after smaller elements and
+		// return its position
+		if (c[i + 1] != c[high]) {
+			swap(c[i + 1], c[high]);
+		}
+		return i + 1;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c) {
+		return sortMerge<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S right) {
+		if (left >= right)
+			return 0;
+
+		S mid = left + (right - left) / 2;
+		sortMerge<T,S>(c, left, mid);
+		sortMerge<T,S>(c, mid + 1, right);
+		sortMerge<T,S>(c, left, mid, right);
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S mid, S right) {
+		S n1 = mid - left + 1;
+		S n2 = right - mid;
+
+		// Create temp vectors
+		T L[n1], R[n2];
+
+		// Copy data to temp vectors L[] and R[]
+		for (S i = 0; i < n1; i++)
+			L[i] = c[left + i];
+		for (S j = 0; j < n2; j++)
+			R[j] = c[mid + 1 + j];
+
+		S i = 0, j = 0;
+		S k = left;
+
+		// Merge the temp vectors back
+		// into arr[left..right]
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				c[k] = L[i];
+				i++;
+			}
+			else {
+				c[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		// Copy the remaining elements of L[],
+		// if there are any
+		while (i < n1) {
+			c[k] = L[i];
+			i++;
+			k++;
+		}
+
+		// Copy the remaining elements of R[],
+		// if there are any
+		while (j < n2) {
+			c[k] = R[j];
+			j++;
+			k++;
+		}
+		return 0;
+	}
+	
+	/** MERGE SORT - END **/
+};
+
+
 } // namespace BF
 
 #endif // ARRAY_HPP
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 8e24ea3d..7789c952 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -10,7 +10,6 @@
 #include "vector.hpp"
 #include "exception.hpp"
 #include "swap.hpp"
-#include "sort.hpp"
 #include <iostream>
 #include <initializer_list>
 
@@ -938,7 +937,7 @@ template <> struct Sort<List> {
 		head = sortMerge<L,S>(head);
 		second = sortMerge<L,S>(second);
 
-		return sortMerge(head, second);
+		return sortMerge<L,S>(head, second);
 	}
 	
 	template <typename L, typename S = size_t> 
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index a0cf60fe..c76d5293 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -6,8 +6,6 @@
 #ifndef SORT_HPP
 #define SORT_HPP
 
-#include "list.hpp"
-
 namespace BF {
 
 typedef enum {
@@ -22,7 +20,7 @@ template<template <typename...> class T> struct Sort;
 
 // Generic sort function
 template <template <typename...> class ContainerTemplate, typename... Args>
-int sort(ContainerTemplate<Args...>& v) {
+int sort(ContainerTemplate<Args...>& v, SortStrategy strategy = kSortStrategyMerge) {
     Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
     return sorter(v);
 }
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 13d1ada6..7e11db89 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -7,6 +7,7 @@
 #define VECTOR_HPP
 
 #include "collection.hpp"
+#include "sort.hpp"
 
 extern "C" {
 #include <bflibc/swap.h>
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 05abdd60..783664e4 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -9,6 +9,7 @@
 #define ASSERT_PUBLIC_MEMBER_ACCESS
 
 #include <list.hpp>
+#include <array.hpp>
 
 extern "C" {
 #include <bflibc/bflibc.h>
@@ -17,7 +18,7 @@ extern "C" {
 using namespace BF;
 
 template <typename T>
-int run_vectorSort(VectorSort type, size_t listsize, int reps) {
+int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 	int result = 0;
 	int max = reps;
 	while (!result && max--) {
@@ -33,7 +34,8 @@ int run_vectorSort(VectorSort type, size_t listsize, int reps) {
 			l.add(val);
 		}
 
-		result = l.sort(type);
+		//result = l.sort(type);
+		result = sort(l);
 
 		if (!result) {
 			if (l.size() != maxsize) {
@@ -62,52 +64,52 @@ int run_vectorSort(VectorSort type, size_t listsize, int reps) {
 }
 
 BFTEST_UNIT_FUNC(test_vectorListSortBubble, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortBubble, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyBubble, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortInsertion, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortInsertion, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyInsertion, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortSelection, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortSelection, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategySelection, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortQuick, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortQuick, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyQuick, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortMerge, 1, {
-	int err = run_vectorSort<List<int>>(kVectorSortMerge, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyMerge, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortBubble, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortBubble, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyBubble, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortInsertion, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortInsertion, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyInsertion, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortSelection, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortSelection, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategySelection, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortQuick, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortQuick, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyQuick, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortMerge, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 

From ed5e3d56467f970857c2eb0939c553893eda54b8 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 14:57:57 -0700
Subject: [PATCH 13/27] can sort

---
 bflibcpp/src/array.hpp              | 5 ++---
 bflibcpp/src/list.hpp               | 5 ++---
 bflibcpp/testbench/vector_tests.hpp | 2 +-
 3 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index 0ff737c9..435592e9 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -635,9 +635,8 @@ class Array : public Vector<T,S> {
 
 template <> struct Sort<Array> {
 	template <typename T, typename S = size_t> 
-	int operator()(Array<T,S> & array) {
-		SortStrategy type = kSortStrategyMerge;
-		switch (type) {
+	int operator()(Array<T,S> & array, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
 			case kSortStrategyBubble:
 				return Sort::sortBubble<T,S>(array);
 			case kSortStrategyInsertion:
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 7789c952..c7ece962 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -744,9 +744,8 @@ class List : public Vector<L,S> {
 
 template <> struct Sort<List> {
 	template <typename L, typename S = size_t> 
-	int operator()(List<L,S> & list) {
-		SortStrategy type = kSortStrategyMerge;
-		switch (type) {
+	int operator()(List<L,S> & list, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
 			case kSortStrategyBubble:
 				return Sort::sortBubble<L,S>(list);
 			case kSortStrategyInsertion:
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 783664e4..d26b8dba 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -35,7 +35,7 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 		}
 
 		//result = l.sort(type);
-		result = sort(l);
+		result = sort(l, type);
 
 		if (!result) {
 			if (l.size() != maxsize) {

From 910d29162f4e20fc005d56241963c75b92b405a8 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 15:00:05 -0700
Subject: [PATCH 14/27] removing sort code

---
 bflibcpp/src/array.hpp  | 214 -------------------------------------
 bflibcpp/src/list.hpp   | 226 ----------------------------------------
 bflibcpp/src/vector.hpp |   2 +-
 3 files changed, 1 insertion(+), 441 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index 435592e9..40366c40 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -417,220 +417,6 @@ class Array : public Vector<T,S> {
 			return 0;
 		}
 	}
-
-public:
-
-	/**
-	 * sorts the vector in ascending order
-	 *
-	 * default algorithm is merge sort
-	 */
-	virtual int sort(VectorSort type = kVectorSortMerge) {
-		switch (type) {
-			case kVectorSortBubble:
-				return Array::sortBubble(*this);
-			case kVectorSortInsertion:
-				return Array::sortInsertion(*this);
-			case kVectorSortSelection:
-				return Array::sortSelection(*this);
-			case kVectorSortQuick:
-				return Array::sortQuick(*this);
-			case kVectorSortMerge:
-			default:
-				return Array::sortMerge(*this);
-		}
-	}
-
-private:
-	
-	/** BUBBLE SORT - START **/
-
-	static int sortBubble(Array & c) {
-		int n = c.size();
-		bool swapped;
-
-		for (int i = 0; i < n - 1; i++) {
-			swapped = false;
-			for (int j = 0; j < n - i - 1; j++) {
-				if (c[j] > c[j + 1]) {
-					swap(c[j], c[j + 1]);
-					swapped = true;
-				}
-			}
-
-			// If no two elements were swapped, then break
-			if (!swapped)
-				break;
-		}
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	static int sortInsertion(Array & c) {
-		int i, j;
-		T key;
-		int n = c.size();
-		for (i = 1; i < n; i++) {
-			key = c[i];
-			j = i - 1;
-	 
-			// Move elements of arr[0..i-1],
-			// that are greater than key, to one
-			// position ahead of their
-			// current position
-			while (j >= 0 && c[j] > key) {
-				c[j + 1] = c[j];
-				j = j - 1;
-			}
-			c[j + 1] = key;
-		}
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	static int sortSelection(Array & c) {
-		int i, j, min_idx;
-		int n = c.size();
-
-		// One by one move boundary of
-		// unsorted subarray
-		for (i = 0; i < n-1; i++) {
-			// Find the minimum element in
-			// unsorted array
-			min_idx = i;
-			for (j = i+1; j < n; j++)
-				if (c[j] < c[min_idx])
-					min_idx = j;
-
-			// Swap the found minimum element
-			// with the first element
-			if (c[min_idx] != c[i]) {
-				swap(c[min_idx], c[i]);
-			}
-		}
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	static int sortQuick(Array & c) {
-		return sortQuick(c, 0, c.size() - 1);
-	}
-
-	static int sortQuick(Array & c, int low, int high) {
-		if (low < high) {
-			// pi is the partition return index of pivot
-			int pi = sortQuickPartition(c, low, high);
-
-			// Recursion calls for smaller elements
-			// and greater or equals elements
-			sortQuick(c, low, pi - 1);
-			sortQuick(c, pi + 1, high);
-		}
-
-		return 0;
-	}
-
-	static int sortQuickPartition(Array & c, int low, int high) {
-		// Choose the pivot
-		T pivot = c[high];
-	  
-		// Index of smaller element and indicates 
-		// the right position of pivot found so far
-		int i = low - 1;
-
-		// Traverse arr[;ow..high] and move all smaller
-		// elements on left side. Elements from low to 
-		// i are smaller after every iteration
-		for (int j = low; j <= high - 1; j++) {
-			if (c[j] < pivot) {
-				i++;
-				if (c[i] != c[j]) {
-					swap(c[i], c[j]);
-				}
-			}
-		}
-		
-		// Move pivot after smaller elements and
-		// return its position
-		if (c[i + 1] != c[high]) {
-			swap(c[i + 1], c[high]);
-		}
-		return i + 1;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	static int sortMerge(Array & c) {
-		return sortMerge(c, 0, c.size() - 1);
-	}
-
-	static int sortMerge(Array & c, S left, S right) {
-		if (left >= right)
-			return 0;
-
-		S mid = left + (right - left) / 2;
-		sortMerge(c, left, mid);
-		sortMerge(c, mid + 1, right);
-		sortMerge(c, left, mid, right);
-		return 0;
-	}
-
-	static int sortMerge(Array & c, S left, S mid, S right) {
-		S n1 = mid - left + 1;
-		S n2 = right - mid;
-
-		// Create temp vectors
-		T L[n1], R[n2];
-
-		// Copy data to temp vectors L[] and R[]
-		for (S i = 0; i < n1; i++)
-			L[i] = c[left + i];
-		for (S j = 0; j < n2; j++)
-			R[j] = c[mid + 1 + j];
-
-		S i = 0, j = 0;
-		S k = left;
-
-		// Merge the temp vectors back
-		// into arr[left..right]
-		while (i < n1 && j < n2) {
-			if (L[i] <= R[j]) {
-				c[k] = L[i];
-				i++;
-			}
-			else {
-				c[k] = R[j];
-				j++;
-			}
-			k++;
-		}
-
-		// Copy the remaining elements of L[],
-		// if there are any
-		while (i < n1) {
-			c[k] = L[i];
-			i++;
-			k++;
-		}
-
-		// Copy the remaining elements of R[],
-		// if there are any
-		while (j < n2) {
-			c[k] = R[j];
-			j++;
-			k++;
-		}
-		return 0;
-	}
-	
-	/** MERGE SORT - END **/
 };
 
 template <> struct Sort<Array> {
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index c7ece962..b0af2144 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -514,232 +514,6 @@ class List : public Vector<L,S> {
 	/// required interfaces: begin() & end()
 	Iterator begin() const { return this->first(); }
 	Iterator end() const { return NULL; }
-
-public:
-
-	/**
-	 * sorts the vector in ascending order
-	 *
-	 * default algorithm is merge sort
-	 */
-	virtual int sort(VectorSort type = kVectorSortMerge) {
-		switch (type) {
-			case kVectorSortBubble:
-				return List::sortBubble(*this);
-			case kVectorSortInsertion:
-				return List::sortInsertion(*this);
-			case kVectorSortSelection:
-				return List::sortSelection(*this);
-			case kVectorSortQuick:
-				return List::sortQuick(*this);
-			case kVectorSortMerge:
-			default:
-				return List::sortMerge(*this);
-		}
-	}
-
-private:
-	
-	/** BUBBLE SORT - START **/
-
-	static int sortBubble(List & c) {
-		Node * head = c.first();
-		S len = c.size();
-		int itr = 0;
-		bool swapped = false;
-
-		while (itr < len) {
-			Node * trav = head;
-			Node * prev = head;
-			swapped = false;
-			
-			while (trav->next()) {
-				Node * ptr = trav->next();
-				if (trav->object() > ptr->object()) {
-					swapped = true;
-					if (trav == head) {
-						trav->right = ptr->right;
-						ptr->right = trav;
-						prev = ptr;
-						head = prev;
-					} else {
-						trav->right = ptr->right;
-						ptr->right = trav;
-						prev->right = ptr;
-						prev = ptr;
-					}
-
-					continue;
-				}
-				prev = trav;
-				trav = trav->next();
-			}
-
-			if (!swapped) {
-				break;
-			}
-			++itr;
-		}
-
-		c._head = head;
-
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	static Node * sortInsertion(Node * newNode, Node * sorted) {
-		if (!sorted || sorted->object() >= newNode->object()) {
-			newNode->right = sorted;
-			sorted = newNode;
-		} else {
-			Node * curr = sorted;
-			while (curr->right && curr->right->object() < newNode->object()) {
-				curr = curr->next();
-			}
-
-			newNode->right = curr->right;
-			curr->right = newNode;
-		}
-
-		return sorted;
-	}
-
-	static int sortInsertion(List & c) {
-		Node * head = c.first();
-		Node * sorted = NULL;
-		Node * curr = head;
-
-		while (curr) {
-			Node * next = curr->next();
-			sorted = sortInsertion(curr, sorted);
-			curr = next;
-		}
-
-		c._head = sorted;
-
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	static int sortSelection(List & c) {
-		Node * head = c.first();
-		for (Node * start = head; start; start = start->next()) {
-			Node * min = start;
-			for (Node * curr = start->next(); curr; curr = curr->next()) {
-				if (curr->object() < min->object()) {
-					min = curr;
-				}
-			}
-
-			if (min != start) {
-				L val = start->object();
-				start->obj = min->object();
-				min->obj = val;
-			}
-		}
-
-		c._head = head;
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	static int sortQuick(List & c) {
-		Node * head = c.first();
-		Node * tail = c.last();
-
-		sortQuick(head, tail);
-
-		c._head = head;
-		return 0;
-	}
-	
-	static void sortQuick(Node * head, Node * tail) {
-		if (!head || head == tail) {
-			return;
-		}
-
-		Node * pivot = sortQuickGetPivot(head, tail);
-
-		sortQuick(head, pivot);
-		sortQuick(pivot->next(), tail);
-	}
-	
-	static Node * sortQuickGetPivot(Node * head, Node * tail) {
-		Node * pivot = head;
-
-		Node * pre = head;
-		Node * curr = head;
-
-		while (curr != tail->next()) {
-			if (curr->object() < pivot->object()) {
-				BF::swap<L>(curr->obj, pre->right->obj);
-				pre = pre->next();
-			}
-
-			curr = curr->next();
-		}
-
-		BF::swap<L>(pivot->obj, pre->obj);
-
-		return pre;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	static int sortMerge(List & c) {
-		c._head = sortMerge(c._head);
-		return 0;
-	}
-
-	static Node * sortMerge(Node * head) {
-		if (!head || !head->next()) {
-			return head;
-		}
-
-		Node * second = sortMergeSplit(head);
-		head = sortMerge(head);
-		second = sortMerge(second);
-
-		return sortMerge(head, second);
-	}
-	
-	static Node * sortMerge(Node * first, Node * second) {
-		if (!first) return second;
-		if (!second) return first;
-
-		if (first->object() < second->object()) {
-			first->right = sortMerge(first->next(), second);
-			return first;
-		} else {
-			second->right = sortMerge(first, second->next());
-			return second;
-		}
-	}
-
-	static Node * sortMergeSplit(Node * head) {
-		Node * fast = head;
-		Node * slow = head;
-
-		while (fast && fast->next()) {
-			fast = fast->right->right;
-			if (fast) {
-				slow = slow->right;
-			}
-		}
-
-		Node * tmp = slow->right;
-		slow->right = NULL;
-		return tmp;
-	}
-	
-	/** MERGE SORT - END **/
 };
 
 template <> struct Sort<List> {
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 7e11db89..c8418524 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -51,7 +51,7 @@ class Vector : public Collection<S> {
 	 *
 	 * default algorithm is merge sort
 	 */
-	virtual int sort(VectorSort type = kVectorSortMerge) = 0;
+	//virtual int sort(VectorSort type = kVectorSortMerge) = 0;
 
 protected:
 	Vector() : Collection<S>() { }

From 6f82edf0b8dcae868176e9e018d5cf2d1c5b1f1a Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 15:00:57 -0700
Subject: [PATCH 15/27] clean up

---
 bflibcpp/src/vector.hpp | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index c8418524..52150aa0 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -15,14 +15,6 @@ extern "C" {
 
 namespace BF {
 
-typedef enum {
-	kVectorSortBubble = 1,
-	kVectorSortInsertion = 2,
-	kVectorSortSelection = 3,
-	kVectorSortMerge = 4,
-	kVectorSortQuick = 5,
-} VectorSort;
-
 /**
  * This class serves as a base class to all array type
  * implementations. Purpose is to abstract each class such
@@ -46,13 +38,6 @@ class Vector : public Collection<S> {
 		return this->refObjectAtIndex(index);
 	}
 
-	/**
-	 * sorts the vector in ascending order
-	 *
-	 * default algorithm is merge sort
-	 */
-	//virtual int sort(VectorSort type = kVectorSortMerge) = 0;
-
 protected:
 	Vector() : Collection<S>() { }
 };

From 32efb0a4b6f0e40090490a314e2dc6b060662c5d Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 15:04:06 -0700
Subject: [PATCH 16/27] moving sort code to sort.hpp

---
 bflibcpp/src/array.hpp              | 218 --------------
 bflibcpp/src/list.hpp               | 231 --------------
 bflibcpp/src/sort.hpp               | 452 ++++++++++++++++++++++++++++
 bflibcpp/src/vector.hpp             |   5 -
 bflibcpp/testbench/vector_tests.hpp |   1 +
 5 files changed, 453 insertions(+), 454 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index 40366c40..b0bedeee 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -419,224 +419,6 @@ class Array : public Vector<T,S> {
 	}
 };
 
-template <> struct Sort<Array> {
-	template <typename T, typename S = size_t> 
-	int operator()(Array<T,S> & array, SortStrategy strategy = kSortStrategyMerge) {
-		switch (strategy) {
-			case kSortStrategyBubble:
-				return Sort::sortBubble<T,S>(array);
-			case kSortStrategyInsertion:
-				return Sort::sortInsertion<T,S>(array);
-			case kSortStrategySelection:
-				return Sort::sortSelection<T,S>(array);
-			case kSortStrategyQuick:
-				return Sort::sortQuick<T,S>(array);
-			case kSortStrategyMerge:
-			default:
-				return Sort::sortMerge<T,S>(array);
-		}
-	}
-
-	/** BUBBLE SORT - START **/
-
-	template <typename T, typename S = size_t> 
-	static int sortBubble(Array<T,S> & c) {
-		S n = c.size();
-		bool swapped = false;
-
-		for (S i = 0; i < n - 1; i++) {
-			swapped = false;
-			for (S j = 0; j < n - i - 1; j++) {
-				if (c[j] > c[j + 1]) {
-					swap(c[j], c[j + 1]);
-					swapped = true;
-				}
-			}
-
-			// If no two elements were swapped, then break
-			if (!swapped)
-				break;
-		}
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	template <typename T, typename S = size_t> 
-	static int sortInsertion(Array<T,S> & c) {
-		S i, j;
-		T key;
-		S n = c.size();
-		for (i = 1; i < n; i++) {
-			key = c[i];
-			j = i - 1;
-	 
-			// Move elements of arr[0..i-1],
-			// that are greater than key, to one
-			// position ahead of their
-			// current position
-			while (j >= 0 && c[j] > key) {
-				c[j + 1] = c[j];
-				j = j - 1;
-			}
-			c[j + 1] = key;
-		}
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	template <typename T, typename S = size_t> 
-	static int sortSelection(Array<T,S> & c) {
-		S i, j, min_idx;
-		S n = c.size();
-
-		// One by one move boundary of
-		// unsorted subarray
-		for (i = 0; i < n-1; i++) {
-			// Find the minimum element in
-			// unsorted array
-			min_idx = i;
-			for (j = i+1; j < n; j++)
-				if (c[j] < c[min_idx])
-					min_idx = j;
-
-			// Swap the found minimum element
-			// with the first element
-			if (c[min_idx] != c[i]) {
-				swap(c[min_idx], c[i]);
-			}
-		}
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	template <typename T, typename S = size_t> 
-	static int sortQuick(Array<T,S> & c) {
-		return sortQuick<T,S>(c, 0, c.size() - 1);
-	}
-
-	template <typename T, typename S = size_t> 
-	static int sortQuick(Array<T,S> & c, S low, S high) {
-		if (low < high) {
-			// pi is the partition return index of pivot
-			S pi = sortQuickPartition<T,S>(c, low, high);
-
-			// Recursion calls for smaller elements
-			// and greater or equals elements
-			sortQuick<T,S>(c, low, pi - 1);
-			sortQuick<T,S>(c, pi + 1, high);
-		}
-
-		return 0;
-	}
-
-	template <typename T, typename S = size_t> 
-	static int sortQuickPartition(Array<T,S> & c, S low, S high) {
-		// Choose the pivot
-		T pivot = c[high];
-	  
-		// Index of smaller element and indicates 
-		// the right position of pivot found so far
-		S i = low - 1;
-
-		// Traverse arr[;ow..high] and move all smaller
-		// elements on left side. Elements from low to 
-		// i are smaller after every iteration
-		for (S j = low; j <= high - 1; j++) {
-			if (c[j] < pivot) {
-				i++;
-				if (c[i] != c[j]) {
-					swap(c[i], c[j]);
-				}
-			}
-		}
-		
-		// Move pivot after smaller elements and
-		// return its position
-		if (c[i + 1] != c[high]) {
-			swap(c[i + 1], c[high]);
-		}
-		return i + 1;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c) {
-		return sortMerge<T,S>(c, 0, c.size() - 1);
-	}
-
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c, S left, S right) {
-		if (left >= right)
-			return 0;
-
-		S mid = left + (right - left) / 2;
-		sortMerge<T,S>(c, left, mid);
-		sortMerge<T,S>(c, mid + 1, right);
-		sortMerge<T,S>(c, left, mid, right);
-		return 0;
-	}
-
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c, S left, S mid, S right) {
-		S n1 = mid - left + 1;
-		S n2 = right - mid;
-
-		// Create temp vectors
-		T L[n1], R[n2];
-
-		// Copy data to temp vectors L[] and R[]
-		for (S i = 0; i < n1; i++)
-			L[i] = c[left + i];
-		for (S j = 0; j < n2; j++)
-			R[j] = c[mid + 1 + j];
-
-		S i = 0, j = 0;
-		S k = left;
-
-		// Merge the temp vectors back
-		// into arr[left..right]
-		while (i < n1 && j < n2) {
-			if (L[i] <= R[j]) {
-				c[k] = L[i];
-				i++;
-			}
-			else {
-				c[k] = R[j];
-				j++;
-			}
-			k++;
-		}
-
-		// Copy the remaining elements of L[],
-		// if there are any
-		while (i < n1) {
-			c[k] = L[i];
-			i++;
-			k++;
-		}
-
-		// Copy the remaining elements of R[],
-		// if there are any
-		while (j < n2) {
-			c[k] = R[j];
-			j++;
-			k++;
-		}
-		return 0;
-	}
-	
-	/** MERGE SORT - END **/
-};
-
-
 } // namespace BF
 
 #endif // ARRAY_HPP
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index b0af2144..d9ecd7e0 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -516,237 +516,6 @@ class List : public Vector<L,S> {
 	Iterator end() const { return NULL; }
 };
 
-template <> struct Sort<List> {
-	template <typename L, typename S = size_t> 
-	int operator()(List<L,S> & list, SortStrategy strategy = kSortStrategyMerge) {
-		switch (strategy) {
-			case kSortStrategyBubble:
-				return Sort::sortBubble<L,S>(list);
-			case kSortStrategyInsertion:
-				return Sort::sortInsertion<L,S>(list);
-			case kSortStrategySelection:
-				return Sort::sortSelection<L,S>(list);
-			case kSortStrategyQuick:
-				return Sort::sortQuick<L,S>(list);
-			case kSortStrategyMerge:
-			default:
-				return Sort::sortMerge<L,S>(list);
-		}
-	}
-
-	/** BUBBLE SORT - START **/
-
-	template <typename L, typename S = size_t> 
-	static int sortBubble(List<L,S> & c) {
-		typename List<L,S>::Node * head = c.first();
-		S len = c.size();
-		int itr = 0;
-		bool swapped = false;
-
-		while (itr < len) {
-			typename List<L,S>::Node * trav = head;
-			typename List<L,S>::Node * prev = head;
-			swapped = false;
-			
-			while (trav->next()) {
-				typename List<L,S>::Node * ptr = trav->next();
-				if (trav->object() > ptr->object()) {
-					swapped = true;
-					if (trav == head) {
-						trav->right = ptr->right;
-						ptr->right = trav;
-						prev = ptr;
-						head = prev;
-					} else {
-						trav->right = ptr->right;
-						ptr->right = trav;
-						prev->right = ptr;
-						prev = ptr;
-					}
-
-					continue;
-				}
-				prev = trav;
-				trav = trav->next();
-			}
-
-			if (!swapped) {
-				break;
-			}
-			++itr;
-		}
-
-		c._head = head;
-
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
-		if (!sorted || sorted->object() >= newNode->object()) {
-			newNode->right = sorted;
-			sorted = newNode;
-		} else {
-			typename List<L,S>::Node * curr = sorted;
-			while (curr->right && curr->right->object() < newNode->object()) {
-				curr = curr->next();
-			}
-
-			newNode->right = curr->right;
-			curr->right = newNode;
-		}
-
-		return sorted;
-	}
-
-	template <typename L, typename S = size_t> 
-	static int sortInsertion(List<L,S> & c) {
-		typename List<L,S>::Node * head = c.first();
-		typename List<L,S>::Node * sorted = NULL;
-		typename List<L,S>::Node * curr = head;
-
-		while (curr) {
-			typename List<L,S>::Node * next = curr->next();
-			sorted = sortInsertion<L,S>(curr, sorted);
-			curr = next;
-		}
-
-		c._head = sorted;
-
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	template <typename L, typename S = size_t> 
-	static int sortSelection(List<L,S> & c) {
-		typename List<L,S>::Node * head = c.first();
-		for (typename List<L,S>::Node * start = head; start; start = start->next()) {
-			typename List<L,S>::Node * min = start;
-			for (typename List<L,S>::Node * curr = start->next(); curr; curr = curr->next()) {
-				if (curr->object() < min->object()) {
-					min = curr;
-				}
-			}
-
-			if (min != start) {
-				L val = start->object();
-				start->obj = min->object();
-				min->obj = val;
-			}
-		}
-
-		c._head = head;
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	template <typename L, typename S = size_t> 
-	static int sortQuick(List<L,S> & c) {
-		typename List<L,S>::Node * head = c.first();
-		typename List<L,S>::Node * tail = c.last();
-
-		sortQuick<L,S>(head, tail);
-
-		c._head = head;
-		return 0;
-	}
-	
-	template <typename L, typename S = size_t> 
-	static void sortQuick(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
-		if (!head || head == tail) {
-			return;
-		}
-
-		typename List<L,S>::Node * pivot = sortQuickGetPivot<L,S>(head, tail);
-
-		sortQuick<L,S>(head, pivot);
-		sortQuick<L,S>(pivot->next(), tail);
-	}
-	
-	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
-		typename List<L,S>::Node * pivot = head;
-
-		typename List<L,S>::Node * pre = head;
-		typename List<L,S>::Node * curr = head;
-
-		while (curr != tail->next()) {
-			if (curr->object() < pivot->object()) {
-				BF::swap<L>(curr->obj, pre->right->obj);
-				pre = pre->next();
-			}
-
-			curr = curr->next();
-		}
-
-		BF::swap<L>(pivot->obj, pre->obj);
-
-		return pre;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	template <typename L, typename S = size_t> 
-	static int sortMerge(List<L,S> & c) {
-		c._head = sortMerge<L,S>(c._head);
-		return 0;
-	}
-
-	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
-		if (!head || !head->next()) {
-			return head;
-		}
-
-		typename List<L,S>::Node * second = sortMergeSplit<L,S>(head);
-		head = sortMerge<L,S>(head);
-		second = sortMerge<L,S>(second);
-
-		return sortMerge<L,S>(head, second);
-	}
-	
-	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
-		if (!first) return second;
-		if (!second) return first;
-
-		if (first->object() < second->object()) {
-			first->right = sortMerge<L,S>(first->next(), second);
-			return first;
-		} else {
-			second->right = sortMerge<L,S>(first, second->next());
-			return second;
-		}
-	}
-
-	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
-		typename List<L,S>::Node * fast = head;
-		typename List<L,S>::Node * slow = head;
-
-		while (fast && fast->next()) {
-			fast = fast->right->right;
-			if (fast) {
-				slow = slow->right;
-			}
-		}
-
-		typename List<L,S>::Node * tmp = slow->right;
-		slow->right = NULL;
-		return tmp;
-	}
-	
-	/** MERGE SORT - END **/
-};
-
 } // namespace BF
 
 #endif // LIST_HPP
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index c76d5293..af4535e7 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -6,6 +6,9 @@
 #ifndef SORT_HPP
 #define SORT_HPP
 
+#include "list.hpp"
+#include "array.hpp"
+
 namespace BF {
 
 typedef enum {
@@ -24,6 +27,455 @@ int sort(ContainerTemplate<Args...>& v, SortStrategy strategy = kSortStrategyMer
     Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
     return sorter(v);
 }
+
+template <> struct Sort<List> {
+	template <typename L, typename S = size_t> 
+	int operator()(List<L,S> & list, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<L,S>(list);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<L,S>(list);
+			case kSortStrategySelection:
+				return Sort::sortSelection<L,S>(list);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<L,S>(list);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<L,S>(list);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortBubble(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		S len = c.size();
+		int itr = 0;
+		bool swapped = false;
+
+		while (itr < len) {
+			typename List<L,S>::Node * trav = head;
+			typename List<L,S>::Node * prev = head;
+			swapped = false;
+			
+			while (trav->next()) {
+				typename List<L,S>::Node * ptr = trav->next();
+				if (trav->object() > ptr->object()) {
+					swapped = true;
+					if (trav == head) {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev = ptr;
+						head = prev;
+					} else {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev->right = ptr;
+						prev = ptr;
+					}
+
+					continue;
+				}
+				prev = trav;
+				trav = trav->next();
+			}
+
+			if (!swapped) {
+				break;
+			}
+			++itr;
+		}
+
+		c._head = head;
+
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
+		if (!sorted || sorted->object() >= newNode->object()) {
+			newNode->right = sorted;
+			sorted = newNode;
+		} else {
+			typename List<L,S>::Node * curr = sorted;
+			while (curr->right && curr->right->object() < newNode->object()) {
+				curr = curr->next();
+			}
+
+			newNode->right = curr->right;
+			curr->right = newNode;
+		}
+
+		return sorted;
+	}
+
+	template <typename L, typename S = size_t> 
+	static int sortInsertion(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * sorted = NULL;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr) {
+			typename List<L,S>::Node * next = curr->next();
+			sorted = sortInsertion<L,S>(curr, sorted);
+			curr = next;
+		}
+
+		c._head = sorted;
+
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortSelection(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		for (typename List<L,S>::Node * start = head; start; start = start->next()) {
+			typename List<L,S>::Node * min = start;
+			for (typename List<L,S>::Node * curr = start->next(); curr; curr = curr->next()) {
+				if (curr->object() < min->object()) {
+					min = curr;
+				}
+			}
+
+			if (min != start) {
+				L val = start->object();
+				start->obj = min->object();
+				min->obj = val;
+			}
+		}
+
+		c._head = head;
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortQuick(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * tail = c.last();
+
+		sortQuick<L,S>(head, tail);
+
+		c._head = head;
+		return 0;
+	}
+	
+	template <typename L, typename S = size_t> 
+	static void sortQuick(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		if (!head || head == tail) {
+			return;
+		}
+
+		typename List<L,S>::Node * pivot = sortQuickGetPivot<L,S>(head, tail);
+
+		sortQuick<L,S>(head, pivot);
+		sortQuick<L,S>(pivot->next(), tail);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		typename List<L,S>::Node * pivot = head;
+
+		typename List<L,S>::Node * pre = head;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr != tail->next()) {
+			if (curr->object() < pivot->object()) {
+				BF::swap<L>(curr->obj, pre->right->obj);
+				pre = pre->next();
+			}
+
+			curr = curr->next();
+		}
+
+		BF::swap<L>(pivot->obj, pre->obj);
+
+		return pre;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortMerge(List<L,S> & c) {
+		c._head = sortMerge<L,S>(c._head);
+		return 0;
+	}
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
+		if (!head || !head->next()) {
+			return head;
+		}
+
+		typename List<L,S>::Node * second = sortMergeSplit<L,S>(head);
+		head = sortMerge<L,S>(head);
+		second = sortMerge<L,S>(second);
+
+		return sortMerge<L,S>(head, second);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
+		if (!first) return second;
+		if (!second) return first;
+
+		if (first->object() < second->object()) {
+			first->right = sortMerge<L,S>(first->next(), second);
+			return first;
+		} else {
+			second->right = sortMerge<L,S>(first, second->next());
+			return second;
+		}
+	}
+
+	template <typename L, typename S = size_t> 
+	static List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
+		typename List<L,S>::Node * fast = head;
+		typename List<L,S>::Node * slow = head;
+
+		while (fast && fast->next()) {
+			fast = fast->right->right;
+			if (fast) {
+				slow = slow->right;
+			}
+		}
+
+		typename List<L,S>::Node * tmp = slow->right;
+		slow->right = NULL;
+		return tmp;
+	}
+	
+	/** MERGE SORT - END **/
+};
+
+template <> struct Sort<Array> {
+	template <typename T, typename S = size_t> 
+	int operator()(Array<T,S> & array, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<T,S>(array);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<T,S>(array);
+			case kSortStrategySelection:
+				return Sort::sortSelection<T,S>(array);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<T,S>(array);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<T,S>(array);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortBubble(Array<T,S> & c) {
+		S n = c.size();
+		bool swapped = false;
+
+		for (S i = 0; i < n - 1; i++) {
+			swapped = false;
+			for (S j = 0; j < n - i - 1; j++) {
+				if (c[j] > c[j + 1]) {
+					swap(c[j], c[j + 1]);
+					swapped = true;
+				}
+			}
+
+			// If no two elements were swapped, then break
+			if (!swapped)
+				break;
+		}
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortInsertion(Array<T,S> & c) {
+		S i, j;
+		T key;
+		S n = c.size();
+		for (i = 1; i < n; i++) {
+			key = c[i];
+			j = i - 1;
+	 
+			// Move elements of arr[0..i-1],
+			// that are greater than key, to one
+			// position ahead of their
+			// current position
+			while (j >= 0 && c[j] > key) {
+				c[j + 1] = c[j];
+				j = j - 1;
+			}
+			c[j + 1] = key;
+		}
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortSelection(Array<T,S> & c) {
+		S i, j, min_idx;
+		S n = c.size();
+
+		// One by one move boundary of
+		// unsorted subarray
+		for (i = 0; i < n-1; i++) {
+			// Find the minimum element in
+			// unsorted array
+			min_idx = i;
+			for (j = i+1; j < n; j++)
+				if (c[j] < c[min_idx])
+					min_idx = j;
+
+			// Swap the found minimum element
+			// with the first element
+			if (c[min_idx] != c[i]) {
+				swap(c[min_idx], c[i]);
+			}
+		}
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c) {
+		return sortQuick<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c, S low, S high) {
+		if (low < high) {
+			// pi is the partition return index of pivot
+			S pi = sortQuickPartition<T,S>(c, low, high);
+
+			// Recursion calls for smaller elements
+			// and greater or equals elements
+			sortQuick<T,S>(c, low, pi - 1);
+			sortQuick<T,S>(c, pi + 1, high);
+		}
+
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuickPartition(Array<T,S> & c, S low, S high) {
+		// Choose the pivot
+		T pivot = c[high];
+	  
+		// Index of smaller element and indicates 
+		// the right position of pivot found so far
+		S i = low - 1;
+
+		// Traverse arr[;ow..high] and move all smaller
+		// elements on left side. Elements from low to 
+		// i are smaller after every iteration
+		for (S j = low; j <= high - 1; j++) {
+			if (c[j] < pivot) {
+				i++;
+				if (c[i] != c[j]) {
+					swap(c[i], c[j]);
+				}
+			}
+		}
+		
+		// Move pivot after smaller elements and
+		// return its position
+		if (c[i + 1] != c[high]) {
+			swap(c[i + 1], c[high]);
+		}
+		return i + 1;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c) {
+		return sortMerge<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S right) {
+		if (left >= right)
+			return 0;
+
+		S mid = left + (right - left) / 2;
+		sortMerge<T,S>(c, left, mid);
+		sortMerge<T,S>(c, mid + 1, right);
+		sortMerge<T,S>(c, left, mid, right);
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S mid, S right) {
+		S n1 = mid - left + 1;
+		S n2 = right - mid;
+
+		// Create temp vectors
+		T L[n1], R[n2];
+
+		// Copy data to temp vectors L[] and R[]
+		for (S i = 0; i < n1; i++)
+			L[i] = c[left + i];
+		for (S j = 0; j < n2; j++)
+			R[j] = c[mid + 1 + j];
+
+		S i = 0, j = 0;
+		S k = left;
+
+		// Merge the temp vectors back
+		// into arr[left..right]
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				c[k] = L[i];
+				i++;
+			}
+			else {
+				c[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		// Copy the remaining elements of L[],
+		// if there are any
+		while (i < n1) {
+			c[k] = L[i];
+			i++;
+			k++;
+		}
+
+		// Copy the remaining elements of R[],
+		// if there are any
+		while (j < n2) {
+			c[k] = R[j];
+			j++;
+			k++;
+		}
+		return 0;
+	}
+	
+	/** MERGE SORT - END **/
+};
+
 }
 
 #endif // SORT_HPP
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 52150aa0..9955d10e 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -7,11 +7,6 @@
 #define VECTOR_HPP
 
 #include "collection.hpp"
-#include "sort.hpp"
-
-extern "C" {
-#include <bflibc/swap.h>
-}
 
 namespace BF {
 
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index d26b8dba..6d43a456 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -10,6 +10,7 @@
 
 #include <list.hpp>
 #include <array.hpp>
+#include <sort.hpp>
 
 extern "C" {
 #include <bflibc/bflibc.h>

From 0376e4155ee38033939ba36e039b5d85ccd08fc2 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Wed, 23 Apr 2025 15:05:45 -0700
Subject: [PATCH 17/27] Adding notes

---
 bflibcpp/todo.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index 0e7c9a1c..d23e0e4e 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -1,8 +1,10 @@
 
 - [ ] BF::Array to use new/delete for memory allocation
 - [ ] improve List sorting
-	- [ ] move sort logic to array and list
-	- [ ] reevaluate logic location
+	- [x] move sort logic to array and list
+	- [x] reevaluate logic location, moved to sort.hpp
+	- [ ] test if BF::Sort can access elements in list and array
+	- [ ] can I easily add to sort outside of Sort<T> declaration?
 - [ ] Vectors to sort strings
 - [x] String append
 - [x] fix leaks in (RBTree specifically) - replaced with map

From 3faa1edb791969ab6327c446382e22fb5d7231d6 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 12:50:09 -0700
Subject: [PATCH 18/27] saving work

---
 bflibcpp/src/list.hpp               |  2 +-
 bflibcpp/src/sort.hpp               | 13 +++----------
 bflibcpp/src/typesortstrategy.hpp   | 18 ++++++++++++++++++
 bflibcpp/src/vector.hpp             |  3 +++
 bflibcpp/testbench/vector_tests.hpp |  4 +++-
 5 files changed, 28 insertions(+), 12 deletions(-)
 create mode 100644 bflibcpp/src/typesortstrategy.hpp

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index d9ecd7e0..8b286610 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -38,7 +38,7 @@ class List : public Vector<L,S> {
 	 * Bi-directional node
 	 */
 	class Node : public Object {
-		friend List<L, S>;
+		friend List<L,S>;
 	public:
 		Node * next() const {
 			return this->right;
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index af4535e7..d7e93e56 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -6,24 +6,17 @@
 #ifndef SORT_HPP
 #define SORT_HPP
 
-#include "list.hpp"
 #include "array.hpp"
+#include "list.hpp"
+//#include "typesortstrategy.hpp"
 
 namespace BF {
 
-typedef enum {
-	kSortStrategyBubble = 1,
-	kSortStrategyInsertion = 2,
-	kSortStrategySelection = 3,
-	kSortStrategyMerge = 4,
-	kSortStrategyQuick = 5,
-} SortStrategy;
-
 template<template <typename...> class T> struct Sort;
 
 // Generic sort function
 template <template <typename...> class ContainerTemplate, typename... Args>
-int sort(ContainerTemplate<Args...>& v, SortStrategy strategy = kSortStrategyMerge) {
+int sort(ContainerTemplate<Args...>& v) {
     Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
     return sorter(v);
 }
diff --git a/bflibcpp/src/typesortstrategy.hpp b/bflibcpp/src/typesortstrategy.hpp
new file mode 100644
index 00000000..18c54a2e
--- /dev/null
+++ b/bflibcpp/src/typesortstrategy.hpp
@@ -0,0 +1,18 @@
+/**
+ * author: brando
+ * date: 4/23/25
+ */
+
+#ifndef TYPE_SORT_STRATEGY_HPP
+#define TYPE_SORT_STRATEGY_HPP
+
+typedef enum {
+	kSortStrategyBubble = 1,
+	kSortStrategyInsertion = 2,
+	kSortStrategySelection = 3,
+	kSortStrategyMerge = 4,
+	kSortStrategyQuick = 5,
+} SortStrategy;
+
+#endif // TYPE_SORT_STRATEGY_HPP
+
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 9955d10e..0ecd18ce 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -7,6 +7,7 @@
 #define VECTOR_HPP
 
 #include "collection.hpp"
+#include "typesortstrategy.hpp"
 
 namespace BF {
 
@@ -35,7 +36,9 @@ class Vector : public Collection<S> {
 
 protected:
 	Vector() : Collection<S>() { }
+
 };
+
 }
 
 #endif // VECTOR_HPP
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 6d43a456..54ddc4eb 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -36,7 +36,9 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 		}
 
 		//result = l.sort(type);
-		result = sort(l, type);
+		result = sort(l);
+		//Sort<T> sorter;
+		//result = sorter(l, type);
 
 		if (!result) {
 			if (l.size() != maxsize) {

From 915856041479074d8945c69c48e5dc118fbd9042 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 12:57:46 -0700
Subject: [PATCH 19/27] can run

---
 bflibcpp/testbench/vector_tests.hpp | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 54ddc4eb..5fa0889a 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -18,7 +18,8 @@ extern "C" {
 
 using namespace BF;
 
-template <typename T>
+//template <typename T>
+template <template <typename...> class ContainerTemplate, typename... Args>
 int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 	int result = 0;
 	int max = reps;
@@ -26,8 +27,8 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 		usleep(50);
 		size_t maxsize = listsize;
 		srand(time(0));
-		T l;
-		T b;
+		ContainerTemplate<Args...> l;
+		ContainerTemplate<Args...> b;
 		for (size_t i = 0; i < maxsize; i++) {
 			usleep(50);
 			int val = rand();
@@ -67,52 +68,52 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 }
 
 BFTEST_UNIT_FUNC(test_vectorListSortBubble, 1,  {
-	int err = run_vectorSort<List<int>>(kSortStrategyBubble, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyBubble, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortInsertion, 1,  {
-	int err = run_vectorSort<List<int>>(kSortStrategyInsertion, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyInsertion, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortSelection, 1,  {
-	int err = run_vectorSort<List<int>>(kSortStrategySelection, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategySelection, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortQuick, 1,  {
-	int err = run_vectorSort<List<int>>(kSortStrategyQuick, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyQuick, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortMerge, 1, {
-	int err = run_vectorSort<List<int>>(kSortStrategyMerge, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyMerge, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortBubble, 1,  {
-	int err = run_vectorSort<Array<int>>(kSortStrategyBubble, 2 << 9, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyBubble, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortInsertion, 1,  {
-	int err = run_vectorSort<Array<int>>(kSortStrategyInsertion, 2 << 9, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyInsertion, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortSelection, 1,  {
-	int err = run_vectorSort<Array<int>>(kSortStrategySelection, 2 << 9, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategySelection, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortQuick, 1,  {
-	int err = run_vectorSort<Array<int>>(kSortStrategyQuick, 2 << 9, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyQuick, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
-	int err = run_vectorSort<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyMerge, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 

From 307ceea113ce7ff3133f13d3713e3ccbf9551e2f Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 13:01:16 -0700
Subject: [PATCH 20/27] default

---
 bflibcpp/testbench/vector_tests.hpp | 59 ++++++++++++++++++++++++++++-
 1 file changed, 58 insertions(+), 1 deletion(-)

diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 5fa0889a..6a027eda 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -18,7 +18,51 @@ extern "C" {
 
 using namespace BF;
 
-//template <typename T>
+template <typename T>
+int run_vectorSortDefault(SortStrategy type, size_t listsize, int reps) {
+	int result = 0;
+	int max = reps;
+	while (!result && max--) {
+		usleep(50);
+		size_t maxsize = listsize;
+		srand(time(0));
+		T l;
+		T b;
+		for (size_t i = 0; i < maxsize; i++) {
+			usleep(50);
+			int val = rand();
+			b.add(val);
+			l.add(val);
+		}
+
+		result = sort(l);
+
+		if (!result) {
+			if (l.size() != maxsize) {
+				result = 2;
+			}
+		}
+
+		if (!result) {
+			for (size_t i = 1; i < maxsize; i++) {
+				usleep(50);
+				if (l[i - 1] > l[i]) {
+					result = 1;
+					break;
+				}
+			}
+			for (size_t i = 0; i < maxsize; i++) {
+				usleep(50);
+				if (!l.contains(b[i])) {
+					result = 3;
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
 template <template <typename...> class ContainerTemplate, typename... Args>
 int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 	int result = 0;
@@ -117,6 +161,16 @@ BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
 	BF_ASSERT(err == 0);
 })
 
+BFTEST_UNIT_FUNC(test_vectorArraySortDefault, 1,  {
+	int err = run_vectorSortDefault<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
+	BF_ASSERT(err == 0);
+})
+
+BFTEST_UNIT_FUNC(test_vectorListSortDefault, 1,  {
+	int err = run_vectorSortDefault<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
+	BF_ASSERT(err == 0);
+})
+
 BFTEST_COVERAGE_FUNC(vector_tests, {
 	BFTEST_LAUNCH(test_vectorListSortBubble);
 	BFTEST_LAUNCH(test_vectorListSortInsertion);
@@ -128,6 +182,9 @@ BFTEST_COVERAGE_FUNC(vector_tests, {
 	BFTEST_LAUNCH(test_vectorArraySortSelection);
 	BFTEST_LAUNCH(test_vectorArraySortQuick);
 	BFTEST_LAUNCH(test_vectorArraySortMerge);
+	BFTEST_LAUNCH(test_vectorArraySortDefault);
+	BFTEST_LAUNCH(test_vectorListSortDefault);
+
 })
 
 #endif // VECTOR_TESTS_HPP

From b5a3e0d094b175b01537b29084df536d8d42e86f Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 13:02:45 -0700
Subject: [PATCH 21/27] issue

---
 bflibcpp/testbench/vector_tests.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 6a027eda..dd453335 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -81,9 +81,9 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 		}
 
 		//result = l.sort(type);
-		result = sort(l);
-		//Sort<T> sorter;
-		//result = sorter(l, type);
+		//result = sort(l);
+		Sort<ContainerTemplate> sorter;
+		result = sorter(l, type);
 
 		if (!result) {
 			if (l.size() != maxsize) {

From ea4f138cae51e71c35be92ceb394c62df7d1ba0a Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 13:46:54 -0700
Subject: [PATCH 22/27] can work

---
 bflibcpp/src/array.hpp              |  2 +-
 bflibcpp/src/list.hpp               | 30 ++++++++++++++++-------------
 bflibcpp/src/vector.hpp             |  2 +-
 bflibcpp/testbench/list_tests.hpp   |  8 ++++----
 bflibcpp/testbench/tests.cpp        |  6 ------
 bflibcpp/testbench/vector_tests.hpp |  2 --
 6 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index b0bedeee..342ea990 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -27,7 +27,7 @@ namespace BF {
  * Objects stored in array are assumed to be owned by owner of array 
  * object
  */
-template <typename T, typename S = size_t>
+template <typename T, typename S = long>
 class Array : public Vector<T,S> {
 public:
 	virtual const char * className() const {
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 8b286610..47bf6c2f 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -30,7 +30,7 @@ namespace BF {
  * Unless a callback is specified, by default the node
  * object memory will not be deallocated.
  */
-template <typename L, typename S = size_t>
+template <typename L, typename S = long>
 class List : public Vector<L,S> {
 public:
 	
@@ -208,13 +208,13 @@ class List : public Vector<L,S> {
 	// returns object at index
 	// returns 0 if an error ocurred
 	virtual L objectAtIndex(S index) const {
-		Node * n = this->nodeAtIndex(index, this->_head, 0);
+		Node * n = this->nodeAtIndex(index, this->_head);
 		if (n) return n->object();
 		else return 0;
 	}
 
 	virtual L & refObjectAtIndex(S index) {
-		Node * n = this->nodeAtIndex(index, this->_head, 0);
+		Node * n = this->nodeAtIndex(index, this->_head);
 		if (n) return n->refobject();
 		throw Exception("no object found at %d", (int) index);
 	}
@@ -277,7 +277,7 @@ class List : public Vector<L,S> {
 		for (; n; n = n->prev()) {
 			// Get random node
 			int r = rand() % (i + 1);
-			Node * tmp = this->nodeAtIndex(r, this->_head, 0);
+			Node * tmp = this->nodeAtIndex(r, this->_head);
 			BF::swap<L>(n->obj, tmp->obj); // swap nodes
 			i--;
 		}
@@ -341,16 +341,20 @@ class List : public Vector<L,S> {
 	}
 
 	/**
-	 * Recursively traverses through linked list until we read the reqIndex'th node
+	 * iteratively traverses through linked list until we read the reqIndex'th node
+	 *
+	 * we start with the search from the `node` param
+	 * 
+	 * if reqIndex < 0, returns NULL
 	 */
-	Node * nodeAtIndex(S reqIndex, Node * node, S currIndex) const {
-		if (node) {
-			if (currIndex == reqIndex) {
-				return node;
-			} else {
-				return this->nodeAtIndex(reqIndex, node->right, ++currIndex);
-			}
-		} else return 0;
+	Node * nodeAtIndex(S reqIndex, Node * node) const {
+		if (reqIndex < 0) return NULL;
+
+		while (--reqIndex >= 0 && node) {
+			node = node->right;
+		}
+
+		return node;
 	}
 
 	/**
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 0ecd18ce..9267d852 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -17,7 +17,7 @@ namespace BF {
  * that I can have a set of mutable functions like sorting
  * to be used across different classes
  */
-template <typename T, typename S = size_t>
+template <typename T, typename S = long>
 class Vector : public Collection<S> {
 public:
 	virtual ~Vector() { }
diff --git a/bflibcpp/testbench/list_tests.hpp b/bflibcpp/testbench/list_tests.hpp
index 15f5fcfb..373e963f 100644
--- a/bflibcpp/testbench/list_tests.hpp
+++ b/bflibcpp/testbench/list_tests.hpp
@@ -40,8 +40,8 @@ BFTEST_UNIT_FUNC(test_indexing, 2<<10, {
 	BF_ASSERT(l->add(1.0) == 0);
 	BF_ASSERT(l->add(1.2) == 0);
 	BF_ASSERT(l->add(1.3) == 0);
-	BF_ASSERT(l->objectAtIndex(0) == 1.0);
-	BF_ASSERT(l->objectAtIndex(1) == 1.2);
+	BF_ASSERT(l->objectAtIndex(0) == 1.0, "%f != 1.0", l->objectAtIndex(0));
+	BF_ASSERT(l->objectAtIndex(1) == 1.2, "%f != 1.2", l->objectAtIndex(1));
 
 	BFRelease(l);
 })
@@ -117,9 +117,9 @@ BFTEST_UNIT_FUNC(test_listMemoryHandling, 2<<10, {
 	BF_ASSERT(!l->deleteObjectAtIndex(0));
 	BF_ASSERT(l->count() == (listsize - 1), "count: %ld\n", l->count());
 
-	int index = BFRand() % l->count();
+	int index = BFMathAbs(BFRand() % l->count());
 	int * num = l->objectAtIndex(index);
-	BF_ASSERT(num != NULL, "num is null");
+	BF_ASSERT(num != NULL, "num is null at index=%d", index);
 	BF_ASSERT(*num == index+1, "list[%d]=%d", index, *num);
 
 	l->deleteAll();
diff --git a/bflibcpp/testbench/tests.cpp b/bflibcpp/testbench/tests.cpp
index 83e595f5..77ef3eac 100644
--- a/bflibcpp/testbench/tests.cpp
+++ b/bflibcpp/testbench/tests.cpp
@@ -22,27 +22,21 @@
 #include "defer_tests.hpp"
 
 BFTEST_SUITE_FUNC({
-	/*
 	BFTEST_SUITE_LAUNCH(atomic_tests);
 	BFTEST_SUITE_LAUNCH(string_tests);
 	BFTEST_SUITE_LAUNCH(stack_tests);
 	BFTEST_SUITE_LAUNCH(queue_tests);
 	BFTEST_SUITE_LAUNCH(time_tests);
 	BFTEST_SUITE_LAUNCH(data_tests);
-	*/
 	BFTEST_SUITE_LAUNCH(array_tests);
 	BFTEST_SUITE_LAUNCH(vector_tests);
-	/*
 	BFTEST_SUITE_LAUNCH(map_tests);
 	BFTEST_SUITE_LAUNCH(object_tests);
-	*/
 	BFTEST_SUITE_LAUNCH(list_tests);
-	/*
 	BFTEST_SUITE_LAUNCH(hashmap_tests);
 	BFTEST_SUITE_LAUNCH(exception_tests);
 	BFTEST_SUITE_LAUNCH(tree_tests);
 	BFTEST_SUITE_LAUNCH(url_tests);
 	BFTEST_SUITE_LAUNCH(defer_tests);
-	*/
 })
 
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index dd453335..c905e560 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -80,8 +80,6 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 			l.add(val);
 		}
 
-		//result = l.sort(type);
-		//result = sort(l);
 		Sort<ContainerTemplate> sorter;
 		result = sorter(l, type);
 

From a820a1d1af9a2414a69c5170dfb5c6e93a295745 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 15:01:17 -0700
Subject: [PATCH 23/27] update todo

---
 bflibcpp/todo.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index d23e0e4e..70aed578 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -4,7 +4,7 @@
 	- [x] move sort logic to array and list
 	- [x] reevaluate logic location, moved to sort.hpp
 	- [ ] test if BF::Sort can access elements in list and array
-	- [ ] can I easily add to sort outside of Sort<T> declaration?
+	- [x] can I easily add to sort outside of Sort<T> declaration?
 - [ ] Vectors to sort strings
 - [x] String append
 - [x] fix leaks in (RBTree specifically) - replaced with map

From c19c46fdbe3288975392c8b1be778f26a0f624ec Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sat, 26 Apr 2025 15:13:08 -0700
Subject: [PATCH 24/27] adding sort

---
 bflibcpp/src/bflibcpp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bflibcpp/src/bflibcpp.hpp b/bflibcpp/src/bflibcpp.hpp
index 4ec7af35..d3a15998 100644
--- a/bflibcpp/src/bflibcpp.hpp
+++ b/bflibcpp/src/bflibcpp.hpp
@@ -31,6 +31,7 @@
 #include "deque.hpp"
 #include "hash.hpp"
 #include "defer.hpp"
+#include "sort.hpp"
 
 #endif // BFLIBCPP_HPP
 

From 45daab45324447157944eedf1812fd48f122ab3b Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sun, 27 Apr 2025 17:15:56 -0700
Subject: [PATCH 25/27] Access fixes

---
 bflibcpp/src/list.hpp |  5 +++++
 bflibcpp/src/sort.hpp | 10 +++++-----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 47bf6c2f..541d5f78 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -15,6 +15,8 @@
 
 namespace BF {
 
+template<template <typename...> class T> struct Sort;
+
 /**
  * Linked List implementation
  *
@@ -33,12 +35,15 @@ namespace BF {
 template <typename L, typename S = long>
 class List : public Vector<L,S> {
 public:
+	friend struct Sort<List>;
 	
 	/**
 	 * Bi-directional node
 	 */
 	class Node : public Object {
 		friend List<L,S>;
+	
+		friend struct Sort<List>;
 	public:
 		Node * next() const {
 			return this->right;
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index d7e93e56..abdf8d4a 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -90,7 +90,7 @@ template <> struct Sort<List> {
 	/** INSERTION SORT - START **/
 
 	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
+	static typename List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
 		if (!sorted || sorted->object() >= newNode->object()) {
 			newNode->right = sorted;
 			sorted = newNode;
@@ -176,7 +176,7 @@ template <> struct Sort<List> {
 	}
 	
 	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+	static typename List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
 		typename List<L,S>::Node * pivot = head;
 
 		typename List<L,S>::Node * pre = head;
@@ -206,7 +206,7 @@ template <> struct Sort<List> {
 	}
 
 	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
+	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
 		if (!head || !head->next()) {
 			return head;
 		}
@@ -219,7 +219,7 @@ template <> struct Sort<List> {
 	}
 	
 	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
+	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
 		if (!first) return second;
 		if (!second) return first;
 
@@ -233,7 +233,7 @@ template <> struct Sort<List> {
 	}
 
 	template <typename L, typename S = size_t> 
-	static List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
+	static typename List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
 		typename List<L,S>::Node * fast = head;
 		typename List<L,S>::Node * slow = head;
 

From e97f2067a85c472e6ae6dbb7789a543aa39b1094 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sun, 27 Apr 2025 08:45:20 -0700
Subject: [PATCH 26/27] update makefile

---
 bflibcpp/makefile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bflibcpp/makefile b/bflibcpp/makefile
index 67788396..42911649 100644
--- a/bflibcpp/makefile
+++ b/bflibcpp/makefile
@@ -33,11 +33,13 @@ defer
 ifeq ($(CONFIG),release) # release
 BIN_NAME = $(LIB_FILE_NAME_RELEASE)
 FLAGS = $(CPPFLAGS) -Isrc/ $(CPPSTD) -I../bflibc/bin/release
+
 ### Debug settings
 else ifeq ($(CONFIG),debug) # debug
 BIN_NAME = $(LIB_FILE_NAME_DEBUG)
 #ADDR_SANITIZER = -fsanitize=address
 FLAGS = $(CPPFLAGS) -DDEBUG -g -Isrc/ $(ADDR_SANITIZER) $(CPPSTD) -I../bflibc/bin/debug
+
 ### Test settings
 else ifeq ($(CONFIG),test) # test
 BIN_NAME = libbfcpp-test

From 3b093d92c2aabf59454549c7642eec60ff563205 Mon Sep 17 00:00:00 2001
From: Brando <fong.m.brandon97@gmail.com>
Date: Sun, 27 Apr 2025 20:19:42 -0700
Subject: [PATCH 27/27] update todo

---
 bflibcpp/todo.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index 70aed578..9c2e4ecd 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -1,9 +1,9 @@
 
 - [ ] BF::Array to use new/delete for memory allocation
-- [ ] improve List sorting
+- [x] improve List sorting
 	- [x] move sort logic to array and list
 	- [x] reevaluate logic location, moved to sort.hpp
-	- [ ] test if BF::Sort can access elements in list and array
+	- [x] test if BF::Sort can access elements in list and array
 	- [x] can I easily add to sort outside of Sort<T> declaration?
 - [ ] Vectors to sort strings
 - [x] String append