.gitignore

@@ -1,9 +1,7 @@
 wordlists
 test/OUTPUT
-test/SortTimes.txt
 bin/main.out
 build/*.o
 build/main.o
 *.swp
 .vscode
-test/traversal.txt

Makefile

@@ -5,10 +5,7 @@ main: compile link
 
 compile:
 	g++ $(INC) $(STD) -c -o build/main.o src/main.cpp
-	g++ $(INC) $(STD) -c -o build/interface.o src/interface.cpp
+	g++ $(INC) $(STD) -c -o build/sorts.o src/sorts.cpp
-	g++ $(INC) $(STD) -c -o build/sort_controller.o src/sort_controller.cpp
-	g++ $(INC) $(STD) -c -o build/basic_sorts.o src/basic_sorts.cpp
-	g++ $(INC) $(STD) -c -o build/trees.o src/trees.cpp
 
 link:
 	g++ -o bin/main.out build/*.o

README.md

@@ -9,48 +9,34 @@ Run `make` to compile the project.
 Output files get placed into test/SORTED
 
 # Running
-Run the program with chosen arguments
+Run `bin/main.out` with chosen arguments to run program
-
-`bin/main.out [-f filename] [-s sort-type] [-l word]` 
 
 # Commands
-
+## bin/main.out [-a | -f filename | -d]
-## bin/main.out [-a | -f filename | -d | ]
+Ex: `bin/main.out -f test/PERM/perm15K.txt -s merge`
-Ex: `bin/main.out -f test/PERM/perm15K.txt -s bst -l apple`
 
 # Arguments
-
 ## File selection
-> -a | --all
+> -a OR --all
-  - Runs through all the original files (test/PERM/perm[15-150]K.txt)
+- Runs through all the original files (perm15K.txt - perm150K.txt)
   - *EX: bin/main.out -a*
-> -f path/to/file.txt | --filename path/to/file.txt
+> -f path/to/file.txt OR --filename path/to/file.txt
 - Runs a specific file to sort
   - *EX: bin/main.out -f perm15K.txt*
-> -d | --default
+> -d OR --default (**default**)
-  - Runs sort only on the default test file (located test/PERM/perm15K.txt)
+- Runs sort only on the default test file (perm15K.txt)
   - *EX: bin/main.out -d*
-> -o | --output
-  - Set file for outputting InOrderTreeTraversal
-  - *EX: bin/main.out -f test/PERM/perm15K.txt -s bst -o test/traversal.txt*
-
 ## Sorting type selection
 > -s | --sort-type
   - Selects a sort type
   - Options:
-      - binary search tree [***default***]
-        - *EX: bin/main.out -s bst*
-      - red-black tree
-        - *EX: bin/main.out -s rbt*
       - insertion
         - *EX: bin/main.out -s insertion*
       - merge
         - *EX: bin/main.out -s merge*
       - heap
         - *EX: bin/main.out -s heap*
-      - all (only runs insertion, merge, and heap sort)
+      - all (**default**)
         - *EX: bin/main.out -s all*
 
 # Notes
-  - Filename for i/o and implementation are preselected through the CLI.
-  - BST and RBT specific methods are called once program has constructed it

include/basic_sorts.hpp

@@ -1,26 +0,0 @@
-#ifndef BASIC_SORTS_HPP
-#define BASIC_SORTS_HPP
-
-#include <string>
-#include <vector>
-
-// Different basic sorting algorithm implementations
-namespace basic_sorts
-{
-    // Performs Insertion Sort on given word list (vector of strings)
-    void InsertionSort(std::vector<std::string> *newWordList);
-
-    // Performs Merge Sort on given word list (vector of strings)
-    void MergeSort(std::vector<std::string> *newWordList);
-    void _MergeSort(std::vector<std::string> *newWordList, int p, int r);
-    void _Merge(std::vector<std::string> *newWordList, int p, int q, int r);
-
-    // Performs Heap Sort on given word list (vector of strings)
-    void HeapSort(std::vector<std::string> *newWordList);
-    void _HeapSort(std::vector<std::string> *newWordList);
-    void _Heapify(std::vector<std::string> *newWordList, int i, int heapSize);
-    int _HEAPSORT_LEFT(int i);
-    int _HEAPSORT_RIGHT(int i);
-}
-
-#endif

include/interface.hpp

@@ -1,33 +0,0 @@
-#ifndef INTERFACE_HPP
-#define INTERFACE_HPP
-
-#include "sort_controller.hpp"
-#include <string>
-#include <vector>
-
-class Interface
-{
-public:
-    SortController benchmark;
-    Interface(void);
-    void CheckArguments(int argc, char* arguments[]);
-    void Construction(void);
-    bool IsBST(void);
-    bool IsOnlySorting(void);
-    void Sort(void);
-    bool UserInput(void);
-    void BSTRequestExecution(void);
-    void RBTRequestExecution(void);
-protected:
-    ;
-private:
-    int userInput;
-    std::string givenWord;
-    SortType currentType;
-    bool allLists, sortGiven;
-    void CheckRequirements(void);
-    void PrintHelp(void);
-    void PrintOptions(void);
-};
-
-#endif

include/sort_controller.hpp

@@ -1,66 +0,0 @@
-#ifndef SORT_CONTROLLER_HPP
-#define SORT_CONTROLLER_HPP
-
-#include "trees.hpp"
-#include <chrono>
-#include <fstream>
-#include <string>
-#include <vector>
-
-enum SortType {INSERTION = 0, MERGE, HEAP, BST, RBT, LAST};
-
-class SortController
-{
-public:
-    std::ofstream outputFile;
-    SortController();
-    void CheckArguments(int argc, char* arguments[]);
-    void ReadWordFile(void);
-    void RunBenchmarks(void);
-    void SetFilename(std::string name);
-    std::string GetFilename(void);
-    void SetOutput(std::string filename);
-    bool IsOutputSpecified(void);
-    void TestInsertion(void);
-    void TestMerge(void);
-    void TestHeap(void);
-    void ConstructBST(void);
-    void ConstructRBT(void);
-    void BSTInsert(std::string key);
-    void BSTSearch(std::string key);
-    void BSTInOrderTreeTraversal(std::string key);
-    void BSTPrintParentKey(std::string key);
-    void BSTPrintLeftChild(std::string key);
-    void BSTPrintRightChild(std::string key);
-    void BSTPrintPathToRoot(std::string key);
-    void RBTInsert(std::string key);
-    void RBTSearch(std::string key);
-    void RBTInOrderTreeTraversal(std::string key);
-    void RBTPrintParentKey(std::string key);
-    void RBTPrintLeftChild(std::string key);
-    void RBTPrintRightChild(std::string key);
-    void RBTPrintPathToRoot(std::string key);
-    void RBTPrintColor(std::string key);
-    void RBTPrintParentColor(std::string key);
-    void RBTPrintUncleColor(std::string key);
-protected:
-    ;
-private:
-    std::string filename;
-    SortType currentType;
-    std::string wordToLocate;
-    tree_implementation::BinarySearchTree binarySearchTree;
-    tree_implementation::RedBlackTree redBlackTree;
-    std::chrono::duration<double> sortTime;
-    std::vector<std::string> newWordList;
-    std::vector<std::string> originalWordList;
-    int lineCount;
-    bool defaultFile, defaultOnly, fileGiven, allLists, sortGiven, locate;
-    void Benchmarking(void);
-    void BenchmarkingAll(void);
-    void OutputResult(void);
-    void EchoSortTime(std::string outputFilename);
-    void WriteOutputToFile(std::string outputFilename);
-};
-
-#endif

include/sorts.h

@@ -0,0 +1,45 @@
+#ifndef SORTS_H
+#define SORTS_H
+
+#include <chrono>
+#include <string>
+#include <vector>
+
+enum SortType {INSERTION = 0, MERGE, HEAP};
+
+class Sorter
+{
+private:
+    std::string filename;
+    int lineCount;
+    std::vector<std::string> originalWordList;
+    std::chrono::duration<double> sortTime;
+    int heapSize; // Heap Sort only
+public:
+    Sorter();
+    std::vector<std::string> newWordList;
+    bool defaultFile, defaultOnly, fileGiven, allLists, sortGiven;
+    SortType currentType;
+    std::string GetFilename(void);
+    void SetFilename(std::string newName);
+    void SetWordList(void);
+    void SortAll(void);
+    void RunSorts(void);
+    void __RunSorts__(void);
+    void OutputResult(void);
+    void PrintSortTime(std::string outputFilename);
+    void PrintToFile(std::string outputFilename);
+    void InsertionSort(void);
+    void MergeSort(void);
+    void __MergeSort__(int p, int r);
+    void __Merge__(int p, int q, int r);
+    void HeapSort(void);
+    void __HeapSort__(void);
+    void __Heapify__(int i);
+    int __LEFT__(int i);
+    int __RIGHT__(int i);
+};
+
+void CheckArguments(int argc, char* arguments[], Sorter* sortObj);
+
+#endif

include/trees.hpp

@@ -1,95 +0,0 @@
-#ifndef TREES_HPP
-#define TREES_HPP
-
-#include <fstream>
-#include <memory>
-#include <string>
-#include <vector>
-
-// Namespace for different implementations of trees
-namespace tree_implementation
-{
-    // General nodes for Tree
-    struct TreeNode
-    {
-        std::string key;
-        std::string color;
-        std::shared_ptr<TreeNode> leftChild;
-        std::shared_ptr<TreeNode> rightChild;
-        std::shared_ptr<TreeNode> parent;
-        TreeNode(std::string word);
-    };
-
-    // General list for Tree
-    class TreeList
-    {
-    public:
-        std::shared_ptr<TreeNode> head;
-        TreeList(void);
-        void InsertAtStart(std::string word);
-        void InsertAtEnd(std::string word);
-        void InsertAtPosition(std::string word);
-        void Remove(std::string word);
-        void Print(void);
-    protected:
-        ;
-    private:
-        ;
-    };
-
-    // Base Tree class
-    class TreeInterface
-    {
-    public:
-        TreeList tree;
-        TreeInterface(void);
-        void Search(std::string key);
-        std::shared_ptr<TreeNode> GetNodeWithWord(std::string wordToFind);
-        void InOrderTreeTraversal(std::shared_ptr<TreeNode> viewedNode);
-        void InOrderTreeTraversal(std::shared_ptr<TreeNode> viewedNode, std::ofstream* file);
-        void PrintParentKey(std::string key);
-        void PrintLeftChild(std::string key);
-        void PrintRightChild(std::string key);
-    protected:
-        bool IsNodeSearchSuccessful(std::shared_ptr<TreeNode> foundNode, std::string key);
-        virtual void Insert(std::shared_ptr<TreeNode> z);
-        virtual void InsertWordList(std::vector<std::string>* newWordList) = 0;
-        virtual void PrintPathToRoot(std::string key) = 0;
-    private:
-        std::shared_ptr<TreeNode> GetNodeWithWord(std::shared_ptr<TreeNode> viewedNode, std::string wordToFind);
-    };
-
-    // Binary Search Tree operations
-    class BinarySearchTree : public TreeInterface
-    {
-    public:
-        void Insert(std::string keyToInsert);
-        void InsertWordList(std::vector<std::string>* newWordList);
-        void PrintPathToRoot(std::string key);
-    protected:
-        ;
-    private:
-        ;
-    };
-
-    // Red-Black Tree operations
-    class RedBlackTree : public TreeInterface
-    {
-    public:
-        void Insert(std::string keyToInsert);
-        void InsertWordList(std::vector<std::string>* newWordList);
-        void PrintPathToRoot(std::string key);
-        void PrintColor(std::string key);
-        void PrintParentColor(std::string key);
-        void PrintUncleColor(std::string key);
-    protected:
-        ;
-    private:
-        void InsertFixup(std::shared_ptr<TreeNode> z);
-        std::shared_ptr<TreeNode> GetUncleNode(std::shared_ptr<TreeNode> startNode);
-        void LeftRotate(std::shared_ptr<TreeNode> x);
-        void RightRotate(std::shared_ptr<TreeNode> x);
-    };
-}
-
-#endif

src/basic_sorts.cpp

@@ -1,129 +0,0 @@
-#include "basic_sorts.hpp"
-#include <string>
-#include <vector>
-
-namespace basic_sorts
-{
-    // Reimplementation of Insertion Sort to be standalone
-    void InsertionSort(std::vector<std::string> *newWordList)
-    {
-        int i;
-        std::string key;
-        for (int j = 1; j < newWordList->size(); j++)
-        {
-            key = newWordList->at(j);
-            i = j - 1;
-            while ((i >= 0) && (newWordList->at(i) > key))
-            {
-                newWordList->at(i + 1) = newWordList->at(i);
-                i = i - 1;
-            }
-            newWordList->at(i + 1) = key;
-        }
-    }
-
-    // Reimplementation of Merge Sort to be standalone
-    void MergeSort(std::vector<std::string> *newWordList)
-    {
-        _MergeSort(newWordList, 0, newWordList->size() - 1);
-        return;
-    }
-
-    void _MergeSort(std::vector<std::string> *newWordList, int p, int r)
-    {
-        if (p < r)
-        {
-            int q = (p + r) / 2;
-            _MergeSort(newWordList, p, q);
-            _MergeSort(newWordList, q+1, r);
-            _Merge(newWordList, p, q, r);
-        }
-        return;
-    }
-
-    void _Merge(std::vector<std::string> *newWordList, int p, int q, int r)
-    {
-        int n1 = q - p + 1;
-        int n2 = r - q;
-        const int leftTmpSize = n1 + 1;
-        const int rightTmpSize = n2 + 1;
-        std::string leftTmp[leftTmpSize];
-        std::string rightTmp[rightTmpSize];
-        for (int i = 0; i < n1; i++)
-            leftTmp[i] = newWordList->at(p + i);
-        for (int i = 0; i < n2; i++)
-            rightTmp[i] = newWordList->at(q + i + 1);
-        leftTmp[n1] = "ZZZZZ";
-        rightTmp[n2] = "ZZZZZ";
-        int i = 0;
-        int j = 0;
-        for (int k = p; k <= r; k++)
-        {
-            if (leftTmp[i] <= rightTmp[j])
-            {
-                newWordList->at(k) = leftTmp[i];
-                i++;
-            } else {
-                newWordList->at(k) = rightTmp[j];
-                j++;
-            }
-        }
-
-    }
-
-    // Reimplementation of Heap Sort to be standalone
-    void HeapSort(std::vector<std::string> *newWordList)
-    {
-        _HeapSort(newWordList);
-        return;
-    }
-
-    void _HeapSort(std::vector<std::string> *newWordList)
-    {
-        std::string tempStr;
-        int heapSize;
-        // Build Max Heap
-        heapSize = newWordList->size();
-        for (int i = ((newWordList->size() / 2) - 1); i >= 0; i--)
-            _Heapify(newWordList, i, heapSize);
-        // Heap Sort
-        for (int i = (newWordList->size() - 1); i >= 0; i--)
-        {
-            tempStr = newWordList->at(i);
-            newWordList->at(i) = newWordList->at(0);
-            newWordList->at(0) = tempStr;
-            heapSize = i;
-            _Heapify(newWordList, 0, heapSize);
-        }
-        return;
-    }
-
-    void _Heapify(std::vector<std::string> *newWordList, int i, int heapSize)
-    {
-        std::string tempStr;
-        int largest = i;
-        int leftIndex = _HEAPSORT_LEFT(i);
-        int rightIndex = _HEAPSORT_RIGHT(i);
-        if ((leftIndex < heapSize) && (newWordList->at(leftIndex) > newWordList->at(largest)))
-            largest = leftIndex;
-        if ((rightIndex < heapSize) && (newWordList->at(rightIndex) > newWordList->at(largest)))
-            largest = rightIndex;
-        if (largest != i)
-        {
-            tempStr = newWordList->at(i);
-            newWordList->at(i) = newWordList->at(largest);
-            newWordList->at(largest) = tempStr;
-            _Heapify(newWordList, largest, heapSize);
-        }
-    }
-
-    int _HEAPSORT_LEFT(int i)
-    {
-        return ((2 * i) + 1);
-    }
-
-    int _HEAPSORT_RIGHT(int i)
-    {
-        return ((2 * i) + 2);
-    }
-}

src/interface.cpp

@@ -1,222 +0,0 @@
-#include "interface.hpp"
-#include <algorithm>
-#include <iostream>
-#include <string>
-#include <vector>
-
-Interface::Interface(void)
-{
-    currentType = INSERTION;
-    allLists = 0;
-    sortGiven = 0;
-    return;
-}
-
-// Checks for command line arguments
-void Interface::CheckArguments(int argc, char* arguments[])
-{
-    std::string tempStr;
-    for (int i = 0; i < argc; i++)
-    {
-        tempStr = arguments[i];
-        if ((tempStr == "-a") || (tempStr == "--all"))
-            allLists = 1;
-        if ((tempStr == "-f") || (tempStr == "--filename"))
-            benchmark.SetFilename(arguments[i + 1]);
-        if ((tempStr == "-d") || (tempStr == "--default"))
-            benchmark.SetFilename("test/PERM/perm15K.txt");
-        if ((tempStr == "-o") || (tempStr == "--output"))
-            benchmark.SetOutput(arguments[i + 1]);
-        if ((tempStr == "-s") || (tempStr == "--sort-type"))
-        {
-            sortGiven = 1;
-            tempStr = arguments[i + 1];
-            if (tempStr == "bst")
-                currentType = BST;
-            if (tempStr == "rbt")
-                currentType = RBT;
-            if (tempStr == "insertion")
-                currentType = INSERTION;
-            if (tempStr == "merge")
-                currentType = MERGE;
-            if (tempStr == "heap")
-                currentType = HEAP;
-            if (tempStr == "all")
-                sortGiven = 0;
-        }
-    }
-    return;
-}
-
-void Interface::Construction(void)
-{
-    CheckRequirements();
-    benchmark.ReadWordFile();
-    if (currentType == BST)
-        benchmark.ConstructBST();
-    if (currentType == RBT)
-        benchmark.ConstructRBT();
-}
-
-bool Interface::IsBST(void)
-{
-    if (currentType == BST) return true;
-    return false;
-}
-
-bool Interface::IsOnlySorting(void)
-{
-    if ((currentType == INSERTION) || (currentType == MERGE) || (currentType == HEAP))
-        return true;
-    return false;
-}
-
-void Interface::Sort(void)
-{
-    ;
-}
-
-bool Interface::UserInput(void)
-{
-    PrintOptions();
-    std::cin >> userInput;
-    if (!userInput) return 0;
-    std::cout << "Enter word you wish to find: ";
-    std::cin >> givenWord;
-    std::transform(givenWord.begin(), givenWord.end(), givenWord.begin(), ::toupper);
-    std::cout << std::endl;
-    return 1;
-}
-
-
-void Interface::BSTRequestExecution(void)
-{
-    switch (userInput)
-    {
-        case 1:
-            // Insert
-            benchmark.BSTInsert(givenWord);
-            break;
-        case 2:
-            // Search
-            benchmark.BSTSearch(givenWord);
-            break;
-        case 3:
-            // InOrderTreeTraversal
-            benchmark.BSTInOrderTreeTraversal(givenWord);
-            break;
-        case 4:
-            // PrintParentKey
-            benchmark.BSTPrintParentKey(givenWord);
-            break;
-        case 5:
-            // PrintLeftChild
-            benchmark.BSTPrintLeftChild(givenWord);
-            break;
-        case 6:
-            // PrintRightChild
-            benchmark.BSTPrintRightChild(givenWord);
-            break;
-        case 7:
-            // PrintPathToRoot
-            benchmark.BSTPrintPathToRoot(givenWord);
-            break;
-        case 8:
-            // PrintColor
-            std::cout << "This method is not available for BST" << std::endl;
-            break;
-        case 9:
-            // PrintParentColor
-            std::cout << "This method is not available for BST" << std::endl;
-            break;
-        case 10:
-            // PrintUncleColor
-            std::cout << "This method is not available for BST" << std::endl;
-            break;
-        default:
-            std::cout << "Please enter a valid option." << std::endl;
-            std::cout << std::endl << std::endl << std::endl;
-            break;
-    }
-}
-
-void Interface::RBTRequestExecution(void)
-{
-    switch (userInput)
-    {
-        case 1:
-            // Insert
-            benchmark.RBTInsert(givenWord);
-            break;
-        case 2:
-            // Search
-            benchmark.RBTSearch(givenWord);
-            break;
-        case 3:
-            // InOrderTreeTraversal
-            benchmark.RBTInOrderTreeTraversal(givenWord);
-            break;
-        case 4:
-            // PrintParentKey
-            benchmark.RBTPrintParentKey(givenWord);
-            break;
-        case 5:
-            // PrintLeftChild
-            benchmark.RBTPrintLeftChild(givenWord);
-            break;
-        case 6:
-            // PrintRightChild
-            benchmark.RBTPrintRightChild(givenWord);
-            break;
-        case 7:
-            // PrintPathToRoot
-            benchmark.RBTPrintPathToRoot(givenWord);
-            break;
-        case 8:
-            // PrintColor
-            benchmark.RBTPrintColor(givenWord);
-            break;
-        case 9:
-            // PrintParentColor
-            benchmark.RBTPrintParentColor(givenWord);
-            break;
-        case 10:
-            // PrintUncleColor
-            benchmark.RBTPrintUncleColor(givenWord);
-            break;
-        default:
-            std::cout << "Please enter a valid option." << std::endl;
-            std::cout << std::endl << std::endl << std::endl;
-            break;
-    }
-}
-
-void Interface::CheckRequirements(void)
-{
-    if (!sortGiven)
-    {
-        std::cout << "Please enter a sorting type to use." << std::endl;
-        exit(1);
-    }
-    return;
-}
-
-void Interface::PrintOptions(void)
-{
-    std::cout << "General Options:" << std::endl;
-    std::cout << "\t1) Insert" << std::endl;
-    std::cout << "\t2) Search" << std::endl;
-    std::cout << "\t3) InOrderTreeTraversal" << std::endl;
-    std::cout << "\t4) PrintParentKey" << std::endl;
-    std::cout << "\t5) PrintLeftChild" << std::endl;
-    std::cout << "\t6) PrintRightChild" << std::endl;
-    std::cout << "\t7) PrintPathToRoot" << std::endl;
-    std::cout << "Options for RBT:" << std::endl;
-    std::cout << "\t8) PrintColor" << std::endl;
-    std::cout << "\t9) PrintParentColor" << std::endl;
-    std::cout << "\t10) PrintUncleColor" << std::endl;
-    std::cout << "\t0) Exit" << std::endl;
-    std::cout << "Enter the number of the option you wish to use: ";
-    return;
-}
-

src/main.cpp

@@ -1,21 +1,9 @@
-#include "interface.hpp"
+#include "sorts.h"
 
 int main(int argc, char* argv[])
 {
-    Interface session;
+    Sorter newSort;
-    session.CheckArguments(argc, argv);
+    CheckArguments(argc, argv, &newSort);
-    session.Construction();
+    newSort.RunSorts();
-    if (session.IsOnlySorting())
-    {
-        session.Sort();
-        return 0;
-    }
-    while (session.UserInput())
-    {
-        if (session.IsBST())
-            session.BSTRequestExecution();
-        else
-            session.RBTRequestExecution();
-    }
     return 0;
 }

src/sort_controller.cpp

@@ -1,445 +0,0 @@
-#include "sort_controller.hpp"
-#include "basic_sorts.hpp"
-#include "trees.hpp"
-#include <algorithm>
-#include <chrono>
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <vector>
-
-// Initialization function for SortController class
-SortController::SortController()
-{
-    lineCount = 0;
-    currentType = INSERTION;
-    filename = "test/PERM/perm15K.txt";
-    allLists = 0;
-    sortGiven = 0;
-    return;
-}
-
-// Checks for command line arguments
-void SortController::CheckArguments(int argc, char* arguments[])
-{
-    std::string tempStr;
-    for (int i = 0; i < argc; i++)
-    {
-        tempStr = arguments[i];
-        if ((tempStr == "-a") || (tempStr == "--all"))
-        {
-            allLists = 1;
-        }
-        if ((tempStr == "-f") || (tempStr == "--filename"))
-        {
-            filename = arguments[i + 1];
-        }
-        if ((tempStr == "-l") || (tempStr == "--locate"))
-        {
-            wordToLocate = arguments[i + 1];
-            std::transform(wordToLocate.begin(), wordToLocate.end(), wordToLocate.begin(), ::toupper);
-            locate = 1;
-        }
-        if ((tempStr == "-d") || (tempStr == "--default"))
-        {
-            filename = "test/PERM/perm15K.txt";
-        }
-        if ((tempStr == "-s") || (tempStr == "--sort-type"))
-        {
-            sortGiven = 1;
-            tempStr = arguments[i + 1];
-            if (tempStr == "bst")
-                currentType = BST;
-            if (tempStr == "rbt")
-                currentType = RBT;
-            if (tempStr == "insertion")
-                currentType = INSERTION;
-            if (tempStr == "merge")
-                currentType = MERGE;
-            if (tempStr == "heap")
-                currentType = HEAP;
-            if (tempStr == "all")
-                sortGiven = 0;
-        }
-    }
-    return;
-}
-
-// Sets word list found in file into vector 
-void SortController::ReadWordFile(void)
-{
-    std::string bufferStr;
-    std::ifstream file(this->filename);
-    if (!file.is_open())
-    {
-        std::cout << "Failed opening file: " << this->filename << '\n';
-        exit(1);
-    }
-    while (getline(file, bufferStr))
-    {
-        originalWordList.push_back(bufferStr);
-        lineCount++;
-    }
-    return;
-}
-
-// Main function for calling all sort categories
-void SortController::RunBenchmarks(void)
-{
-    if (allLists)
-    {
-        BenchmarkingAll();
-        return;
-    }
-    ReadWordFile();
-    Benchmarking();
-    return;
-}
-
-
-void SortController::SetFilename(std::string name)
-{
-    filename = name;
-    return;
-}
-
-std::string SortController::GetFilename(void)
-{
-    return filename;
-}
-
-void SortController::SetOutput(std::string filename)
-{
-    outputFile.open(filename);
-    return;
-}
-
-bool SortController::IsOutputSpecified(void)
-{
-    return outputFile.is_open();
-}
-
-
-void SortController::TestInsertion(void)
-{
-    newWordList = originalWordList;
-    auto start = std::chrono::system_clock::now();
-    basic_sorts::InsertionSort(&newWordList);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    OutputResult();
-}
-
-void SortController::TestMerge(void)
-{
-    newWordList = originalWordList;
-    auto start = std::chrono::system_clock::now();
-    basic_sorts::MergeSort(&newWordList);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    OutputResult();
-}
-
-void SortController::TestHeap(void)
-{
-    newWordList = originalWordList;
-    auto start = std::chrono::system_clock::now();
-    basic_sorts::HeapSort(&newWordList);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    OutputResult();
-}
-
-void SortController::ConstructBST(void)
-{
-    newWordList = originalWordList;
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.InsertWordList(&newWordList);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "BST construction took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::ConstructRBT(void)
-{
-    newWordList = originalWordList;
-    tree_implementation::RedBlackTree newTree;
-    auto start = std::chrono::system_clock::now();
-    newTree.InsertWordList(&newWordList);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "RBT construction took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTInsert(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.Insert(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTSearch(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.Search(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTInOrderTreeTraversal(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    if (IsOutputSpecified())
-        binarySearchTree.InOrderTreeTraversal(binarySearchTree.GetNodeWithWord(key), &outputFile);
-    else
-        binarySearchTree.InOrderTreeTraversal(binarySearchTree.GetNodeWithWord(key));
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTPrintParentKey(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.PrintParentKey(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTPrintLeftChild(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.PrintLeftChild(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTPrintRightChild(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.PrintRightChild(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::BSTPrintPathToRoot(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    binarySearchTree.PrintPathToRoot(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTInsert(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.Insert(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTSearch(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.Search(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTInOrderTreeTraversal(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    if (IsOutputSpecified())
-        redBlackTree.InOrderTreeTraversal(redBlackTree.GetNodeWithWord(key), &outputFile);
-    else
-        redBlackTree.InOrderTreeTraversal(redBlackTree.GetNodeWithWord(key));
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintParentKey(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintParentKey(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintLeftChild(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintLeftChild(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintRightChild(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintRightChild(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintPathToRoot(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintPathToRoot(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintColor(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintColor(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintParentColor(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintParentColor(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-void SortController::RBTPrintUncleColor(std::string key)
-{
-    auto start = std::chrono::system_clock::now();
-    redBlackTree.PrintUncleColor(key);
-    auto end = std::chrono::system_clock::now();
-    sortTime = end - start;
-    std::cout << "Operation took " << sortTime.count() << 's' << std::endl;
-}
-
-
-// TODO: Depreciated; Clean up
-// Function for starting sort functions
-void SortController::Benchmarking(void)
-{
-    // if (!sortGiven)
-    //     currentType = INSERTION;
-    // if (currentType == INSERTION)
-    // {
-        
-    // }
-    // if (!sortGiven)
-    //     currentType = MERGE;
-    // if (currentType == MERGE)
-    // {
-        
-    // }
-    // if (!sortGiven)
-    //     currentType = HEAP;
-    // if (currentType == HEAP)
-    // {
-        
-    // }
-    // if (currentType == BST)
-    // {
-        
-    // }
-    // if (currentType == RBT)
-    // {
-        
-    //     start = std::chrono::system_clock::now();
-    //     newTree.Search(wordToLocate);
-    //     end = std::chrono::system_clock::now();
-    //     sortTime = end - start;
-    //     EchoSortTime("RBT");
-    //     newTree.PrintPathToRoot(wordToLocate);
-    // }
-}
-
-// Sorts all default files if allLists is set
-void SortController::BenchmarkingAll(void)
-{
-    int fileCount = 10;
-    std::string newFilename;
-    for (int i = 1; i <= fileCount; i++)
-    {
-        lineCount = 0;
-        newFilename = "test/PERM/perm";
-        newFilename += std::to_string(15*i);
-        newFilename += "K.txt";
-        filename = newFilename;
-        ReadWordFile();
-        Benchmarking();
-        originalWordList.clear();
-    } 
-}
-
-
-// Main function for printing results
-void SortController::OutputResult(void)
-{
-    switch(currentType)
-    {
-        case INSERTION:
-            EchoSortTime("IS");
-            WriteOutputToFile("IS");
-            break;
-        case MERGE:
-            EchoSortTime("MS");
-            WriteOutputToFile("MS");
-            break;
-        case HEAP:
-            EchoSortTime("HS");
-            WriteOutputToFile("HS");
-            break;
-        case BST:
-            EchoSortTime("BST");
-            WriteOutputToFile("BST");
-            break;
-        case RBT:
-            EchoSortTime("RBT");
-            WriteOutputToFile("RBT");
-            break;
-        default:
-            break;
-    }
-}
-
-// Prints sort time to the screen
-void SortController::EchoSortTime(std::string outputFilename)
-{
-    std::string sortSizeString = std::to_string(lineCount / 1000);
-    std::cout << outputFilename << sortSizeString;
-    std::cout << " took " << sortTime.count() << " s" << std::endl;
-    return;
-}
-
-// Prints result of sort operation to file
-void SortController::WriteOutputToFile(std::string outputFilename)
-{
-    std::string sortSizeString = std::to_string(lineCount / 1000);
-    std::string outputPath = "test/OUTPUT/";
-    outputPath += outputFilename + sortSizeString + "K.txt";
-    std::ofstream file(outputPath);
-    if (!file.is_open())
-    {
-        std::cout << "Failed opening file\n";
-        exit(1);
-    }
-    for (unsigned int i = 0; i < lineCount; i++)
-        file << newWordList[i] << '\n';
-    file.close();
-}

src/sorts.cpp

@@ -0,0 +1,330 @@
+#include "sorts.h"
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// Initialization function for Sorter class
+Sorter::Sorter()
+{
+    lineCount = 0;
+    currentType = INSERTION;
+    defaultFile = 0;
+    defaultOnly = 1;
+    fileGiven = 0;
+    allLists = 0;
+    sortGiven = 0;
+}
+
+// Sets the current filename
+void Sorter::SetFilename(std::string newName)
+{
+    this->filename = newName;
+}
+
+// Returns the current filename
+std::string Sorter::GetFilename(void)
+{
+    return this->filename;
+}
+
+// Sets word list found in file into vector 
+void Sorter::SetWordList(void)
+{
+    std::string bufferStr;
+    std::ifstream file(this->filename);
+    if (!file.is_open())
+    {
+        std::cout << "Failed opening file: " << this->filename << '\n';
+        exit(1);
+    }
+    while (getline(file, bufferStr))
+    {
+        originalWordList.push_back(bufferStr);
+        lineCount++;
+    }
+    return;
+}
+
+// Main function for calling all sort categories
+void Sorter::RunSorts(void)
+{
+    if (defaultOnly || fileGiven)
+    {
+        SetWordList();
+        __RunSorts__();
+    }
+    if (allLists)
+        SortAll();
+    return;
+}
+
+// Sorts all default files if allLists is set
+void Sorter::SortAll(void)
+{
+    int fileCount = 10;
+    std::string newFilename;
+    for (int i = 1; i <= fileCount; i++)
+    {
+        lineCount = 0;
+        newFilename = "test/SORTED/sorted";
+        newFilename += std::to_string(15*i);
+        newFilename += "K.txt";
+        SetFilename(newFilename);
+        SetWordList();
+        __RunSorts__();
+        originalWordList.clear();
+    } 
+}
+
+// Function for starting sort functions
+void Sorter::__RunSorts__(void)
+{
+    if (!sortGiven)
+        currentType = INSERTION;
+    if (currentType == INSERTION)
+    {
+        newWordList = originalWordList;
+        InsertionSort();
+        OutputResult();
+    }
+    if (!sortGiven)
+        currentType = MERGE;
+    if (currentType == MERGE)
+    {
+        newWordList = originalWordList;
+        MergeSort();
+        OutputResult();
+    }
+    if (!sortGiven)
+        currentType = HEAP;
+    if (currentType == HEAP)
+    {
+        newWordList = originalWordList;
+        HeapSort();
+        OutputResult();
+    }
+}
+
+// Main function for printing results
+void Sorter::OutputResult(void)
+{
+    switch(currentType)
+    {
+        case INSERTION:
+            PrintSortTime("IS");
+            PrintToFile("IS");
+            break;
+        case MERGE:
+            PrintSortTime("MS");
+            PrintToFile("MS");
+            break;
+        case HEAP:
+            PrintSortTime("HS");
+            PrintToFile("HS");
+            break;
+        default:
+            break;
+    }
+}
+
+// Prints sort time to the screen
+void Sorter::PrintSortTime(std::string outputFilename)
+{
+    std::string sortSizeString = std::to_string(lineCount / 1000);
+    std::cout << outputFilename << sortSizeString;
+    std::cout << " took " << sortTime.count() << " s" << std::endl;
+    return;
+}
+
+// Prints result of sort operation to file
+void Sorter::PrintToFile(std::string outputFilename)
+{
+    std::string sortSizeString = std::to_string(lineCount / 1000);
+    std::string outputPath = "test/OUTPUT/";
+    outputPath += outputFilename + sortSizeString + "K.txt";
+    std::ofstream file(outputPath);
+    if (!file.is_open())
+    {
+        std::cout << "Failed opening file\n";
+        exit(1);
+    }
+    for (unsigned int i = 0; i < lineCount; i++)
+        file << newWordList[i] << '\n';
+    file.close();
+}
+
+// Main function for insertion sort
+void Sorter::InsertionSort(void)
+{
+    auto start = std::chrono::system_clock::now();
+    int i;
+    std::string key;
+    for (int j = 1; j < lineCount; j++)
+    {
+        key = newWordList[j];
+        i = j - 1;
+        while ((i >= 0) && (newWordList[i] > key))
+        {
+            newWordList[i + 1] = newWordList[i];
+            i = i - 1;
+        }
+        newWordList[i + 1] = key;
+    }
+    auto end = std::chrono::system_clock::now();
+    sortTime = end - start;
+}
+
+// Main function for merge sort
+void Sorter::MergeSort(void)
+{
+    auto start = std::chrono::system_clock::now();
+    __MergeSort__(0, lineCount - 1);
+    auto end = std::chrono::system_clock::now();
+    sortTime = end - start;
+    return;
+}
+
+// Merge sort function child
+void Sorter::__MergeSort__(int p, int r)
+{
+    if (p < r)
+    {
+        int q = (p + r) / 2;
+        __MergeSort__(p, q);
+        __MergeSort__(q+1, r);
+        __Merge__(p, q, r);
+    }
+    return;
+}
+
+// Merge sort function child
+void Sorter::__Merge__(int p, int q, int r)
+{
+    int n1 = q - p + 1;
+    int n2 = r - q;
+    const int leftTmpSize = n1 + 1;
+    const int rightTmpSize = n2 + 1;
+    std::string leftTmp[leftTmpSize];
+    std::string rightTmp[rightTmpSize];
+    for (int i = 0; i < n1; i++)
+        leftTmp[i] = newWordList[p + i];
+    for (int i = 0; i < n2; i++)
+        rightTmp[i] = newWordList[q + i + 1];
+    leftTmp[n1] = "ZZZZZ";
+    rightTmp[n2] = "ZZZZZ";
+    int i = 0;
+    int j = 0;
+    for (int k = p; k <= r; k++)
+    {
+        if (leftTmp[i] <= rightTmp[j])
+        {
+            newWordList[k] = leftTmp[i];
+            i++;
+        } else {
+            newWordList[k] = rightTmp[j];
+            j++;
+        }
+    }
+}
+
+// Main function for heap sort
+void Sorter::HeapSort(void)
+{
+    auto start = std::chrono::system_clock::now();
+    __HeapSort__();
+    auto end = std::chrono::system_clock::now();
+    sortTime = end - start;
+    return;
+}
+void Sorter::__HeapSort__(void)
+{
+    std::string tempStr;
+    // Build Max Heap
+    heapSize = newWordList.size();
+    for (int i = ((newWordList.size() / 2) - 1); i >= 0; i--)
+        __Heapify__(i);
+    // Heap Sort
+    for (int i = (newWordList.size() - 1); i >= 0; i--)
+    {
+        tempStr = newWordList[i];
+        newWordList[i] = newWordList[0];
+        newWordList[0] = tempStr;
+        heapSize = i;
+        __Heapify__(0);
+    }
+    return;
+}
+
+void Sorter::__Heapify__(int i)
+{
+    std::string tempStr;
+    int largest = i;
+    int leftIndex = __LEFT__(i);
+    int rightIndex = __RIGHT__(i);
+    if ((leftIndex < heapSize) && (newWordList[leftIndex] > newWordList[largest]))
+        largest = leftIndex;
+    if ((rightIndex < heapSize) && (newWordList[rightIndex] > newWordList[largest]))
+        largest = rightIndex;
+    if (largest != i)
+    {
+        tempStr = newWordList[i];
+        newWordList[i] = newWordList[largest];
+        newWordList[largest] = tempStr;
+        __Heapify__(largest);
+    }
+}
+
+int Sorter::__LEFT__(int i)
+{
+    return ((2 * i) + 1);
+}
+
+int Sorter::__RIGHT__(int i)
+{
+    return ((2 * i) + 2);
+}
+
+// Checks for command line arguments
+void CheckArguments(int argc, char* arguments[], Sorter* sortObj)
+{
+    std::string tempStr;
+    for (int i = 0; i < argc; i++)
+    {
+        tempStr = arguments[i];
+        if ((tempStr == "-a") || (tempStr == "--all"))
+        {
+            sortObj->defaultOnly = 0;
+            sortObj->allLists = 1;
+
+        }
+        if ((tempStr == "-f") || (tempStr == "--filename"))
+        {
+            sortObj->SetFilename(arguments[i + 1]);
+            sortObj->defaultOnly = 0;
+            sortObj->fileGiven = 1;
+        }
+        if ((tempStr == "-d") || (tempStr == "--default"))
+        {
+            sortObj->SetFilename("test/PERM/perm15K.txt");
+            sortObj->defaultFile = 1;
+        }
+        if ((tempStr == "-s") || (tempStr == "--sort-type"))
+        {
+            sortObj->sortGiven = 1;
+            tempStr = arguments[i + 1];
+            if (tempStr == "insertion")
+                sortObj->currentType = INSERTION;
+            if (tempStr == "merge")
+                sortObj->currentType = MERGE;
+            if (tempStr == "heap")
+                sortObj->currentType = HEAP;
+            if (tempStr == "all")
+                sortObj->sortGiven = 0;
+        }
+    }
+    if (sortObj->defaultOnly)
+        sortObj->SetFilename("test/PERM/perm15K.txt");
+    return;
+}

src/trees.cpp

@@ -1,356 +0,0 @@
-#include "trees.hpp"
-#include <fstream>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace tree_implementation
-{
-
-    TreeNode::TreeNode(std::string word)
-    {
-        key = word;
-        color = "red";
-        leftChild = nullptr;
-        rightChild = nullptr;
-        this->parent = nullptr;
-        return;
-    }
-
-    TreeList::TreeList(void)
-    {
-        head = nullptr;
-        return;
-    }
-
-    TreeInterface::TreeInterface(void)
-    {
-        return;
-    }
-
-    void TreeInterface::Search(std::string key)
-    {
-        std::cout << std::endl;
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return; 
-        std::cout << "The word '" << key << "' was found in the tree.";
-        std::cout << std::endl;
-    }
-
-    // Inserts a node into a BST
-    void TreeInterface::Insert(std::shared_ptr<TreeNode> z)
-    {
-        std::shared_ptr<TreeNode> y = nullptr;
-        std::shared_ptr<TreeNode> x = tree.head;
-        while (x)
-        {
-            y = x;
-            if (z.get()->key < x.get()->key)
-                x = x.get()->leftChild;
-            else
-                x = x.get()->rightChild;
-        }
-        z.get()->parent = y;
-        if (!y)
-            tree.head = z;
-        else if (z.get()->key < y.get()->key)
-            y->leftChild = z;
-        else
-            y->rightChild = z;
-        return;
-    }
-
-    // Searches for the given word in a tree
-    // Returns a pointer to the node
-    std::shared_ptr<TreeNode> TreeInterface::GetNodeWithWord(std::string wordToFind)
-    {
-        return GetNodeWithWord(tree.head, wordToFind);
-    }
-
-    bool TreeInterface::IsNodeSearchSuccessful(std::shared_ptr<TreeNode> foundNode, std::string key)
-    {
-        if (foundNode)
-            return true;
-        std::cout << "No node found with key " << key << std::endl;
-        return false;
-    }
-
-    // Prints tree while traversing it
-    void TreeInterface::InOrderTreeTraversal(std::shared_ptr<TreeNode> viewedNode)
-    {
-        if (viewedNode)
-        {
-            InOrderTreeTraversal(viewedNode->leftChild);
-            std::cout << viewedNode.get()->key << '\n';
-            InOrderTreeTraversal(viewedNode->rightChild);
-        }
-        return;
-    }
-
-    // Prints tree while traversing it to a file
-    void TreeInterface::InOrderTreeTraversal(std::shared_ptr<TreeNode> viewedNode, std::ofstream* file)
-    {
-        if (viewedNode)
-        {
-            InOrderTreeTraversal(viewedNode->leftChild);
-            *file << viewedNode.get()->key << '\n';
-            InOrderTreeTraversal(viewedNode->rightChild);
-        }
-        return;
-    }
-
-    // Prints the given word's parent's word if found
-    void TreeInterface::PrintParentKey(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        if (!foundNode->parent)
-        {
-            std::cout << "NIL" << std::endl;
-            return;
-        }
-        std::cout << "The parent's word is " << foundNode->parent->key << '\n';
-        return;
-    }
-
-    // Prints the given word's left child's word if found
-    void TreeInterface::PrintLeftChild(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        if (!foundNode->leftChild)
-        {
-            std::cout << "NIL" << std::endl;
-            return;
-        }
-        std::cout << "The left child's word is " << foundNode->leftChild->key << '\n';
-        return;
-    }
-
-    // Prints the given word's right child's word if found
-    void TreeInterface::PrintRightChild(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        if (!foundNode->rightChild)
-        {
-            std::cout << "NIL" << std::endl;
-            return;
-        }
-        std::cout << "The right child's word is " << foundNode->rightChild->key << '\n';
-        return;
-    }
-
-    // Recursive search function for GetNodeWithWord()
-    std::shared_ptr<TreeNode> TreeInterface::GetNodeWithWord(std::shared_ptr<TreeNode> viewedNode, std::string wordToFind)
-    {
-        if ((!viewedNode) || (wordToFind == viewedNode.get()->key))
-            return viewedNode;
-        if (wordToFind < viewedNode.get()->key)
-            return GetNodeWithWord(viewedNode->leftChild, wordToFind);
-        return GetNodeWithWord(viewedNode->rightChild, wordToFind);
-    }
-
-    // Insert a node into a BST
-    void BinarySearchTree::Insert(std::string keyToInsert)
-    {
-        std::shared_ptr<TreeNode> newNode = std::make_shared<TreeNode> (keyToInsert);
-        TreeInterface::Insert(newNode);
-        return;
-    }
-
-    // Insert the entire vector word list into tree
-    void BinarySearchTree::InsertWordList(std::vector<std::string>* newWordList)
-    {
-        for (int i = 0; i < newWordList->size(); i++)
-        {
-            Insert(newWordList->at(i));
-        }
-    }
-
-    // Prints the path to root in a BST
-    void BinarySearchTree::PrintPathToRoot(std::string key)
-    {
-        std::shared_ptr<TreeNode> selectedNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(selectedNode, key)) return;
-        int timesPrintedOnLine = 0;
-        std::cout << "Path from:" << selectedNode->key << std::endl;
-        while (selectedNode = selectedNode.get()->parent)
-        {
-            std::cout << " -> " << selectedNode.get()->key;
-            if (timesPrintedOnLine < 5)
-                timesPrintedOnLine++;
-            else
-            {
-                timesPrintedOnLine = 0;
-                std::cout << std::endl;
-            }
-        } 
-        std::cout << std::endl;
-        return;
-    }
-
-    // Insert a node into a RBT
-    void RedBlackTree::Insert(std::string keyToInsert)
-    {
-        std::shared_ptr<TreeNode> newNode = std::make_shared<TreeNode> (keyToInsert);
-        TreeInterface::Insert(newNode);
-        InsertFixup(newNode);
-        return;
-    }
-
-    // Insert the entire vector word list into tree
-    void RedBlackTree::InsertWordList(std::vector<std::string>* newWordList)
-    {
-        for (int i = 0; i < newWordList->size(); i++)
-        {
-            Insert(newWordList->at(i));
-        }
-    }
-
-    // Print path to root in RBT
-    // TODO: Implement printing path to root for RBT
-    void RedBlackTree::PrintPathToRoot(std::string key)
-    {
-        std::shared_ptr<TreeNode> selectedNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(selectedNode, key)) return;
-        int timesPrintedOnLine = 0;
-        std::cout << "Path from:" << selectedNode->key << std::endl;
-        while (selectedNode = selectedNode.get()->parent)
-        {
-            std::cout << " -> " << selectedNode.get()->key;
-            std::cout << '(' << selectedNode.get()->color << ')';
-            if (timesPrintedOnLine < 5)
-                timesPrintedOnLine++;
-            else
-            {
-                timesPrintedOnLine = 0;
-                std::cout << std::endl;
-            }
-        } 
-        std::cout << std::endl;
-        return;
-    }
-
-    // Print color of word if found in RBT
-    void RedBlackTree::PrintColor(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        std::cout << "The color is " << foundNode->color << '\n';
-        return;
-    }
-
-    // Print color of word's parent if found in RBT
-    void RedBlackTree::PrintParentColor(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        std::cout << "The color is " << foundNode->parent->color << '\n';
-        return;
-    }
-
-    // Print color of word's uncle if found in RBT
-    void RedBlackTree::PrintUncleColor(std::string key)
-    {
-        std::shared_ptr<TreeNode> foundNode = GetNodeWithWord(key);
-        if (!IsNodeSearchSuccessful(foundNode, key)) return;
-        std::cout << "The color is " << GetUncleNode(foundNode).get()->color << '\n';
-        return;
-    }
-
-    void RedBlackTree::InsertFixup(std::shared_ptr<TreeNode> z)
-    {
-        std::shared_ptr<TreeNode> y;
-        while (z->parent && z->parent->color == "red")
-        {
-            if (z->parent == z->parent->parent->leftChild)
-            {
-                y = z->parent->parent->rightChild;
-                if (y && y->color == "red")
-                {
-                    z->parent->color = "black";
-                    y->color = "black";
-                    z->parent->parent->color = "red";
-                    z = z->parent->parent;
-                } else {
-                    if (z == z->parent->rightChild)
-                    {
-                        z = z->parent;
-                        LeftRotate(z);
-                    }
-                    z->parent->color = "black";
-                    z->parent->parent->color = "red";
-                    RightRotate(z->parent->parent);
-                }
-            } else {
-                y = z->parent->parent->leftChild;
-                if (y && y->color == "red")
-                {
-                    z->parent->color = "black";
-                    y->color = "black";
-                    z->parent->parent->color = "red";
-                    z = z->parent->parent;
-                } else {
-                    if (z == z->parent->leftChild)
-                    {
-                        z = z->parent;
-                        RightRotate(z);
-                    }
-                    z->parent->color = "black";
-                    z->parent->parent->color = "red";
-                    LeftRotate(z->parent->parent);
-                }
-            }
-        }
-        tree.head->color = "black";
-        return;
-    }
-
-    // Returns the uncle node in RBT
-    std::shared_ptr<TreeNode> RedBlackTree::GetUncleNode(std::shared_ptr<TreeNode> startNode)
-    {
-        if (startNode->parent == startNode->parent->parent->leftChild)
-            return startNode->parent->parent->rightChild;
-        return startNode->parent->parent->leftChild;
-    }
-
-    // Performs left rotate on a given node
-    void RedBlackTree::LeftRotate(std::shared_ptr<TreeNode> x)
-    {
-        std::shared_ptr<TreeNode> y = x->rightChild;
-        x->rightChild = y->leftChild;
-        if (y->leftChild)
-            y->leftChild->parent = x;
-        y->parent = x->parent;
-        if (!x->parent)
-            tree.head = y;
-        else if (x == x->parent->leftChild)
-            x->parent->leftChild = y;
-        else
-            x->parent->rightChild = y;
-        y->leftChild = x;
-        x->parent = y;
-        return;
-    }
-
-    // Performs right rotate on a given node
-    void RedBlackTree::RightRotate(std::shared_ptr<TreeNode> x)
-    {
-        std::shared_ptr<TreeNode> y = x->leftChild;
-        x->leftChild = y->rightChild;
-        if (y->rightChild)
-            y->rightChild->parent = x;
-        y->parent = x->parent;
-        if (!x->parent)
-            tree.head = y;
-        else if (x == x->parent->leftChild)
-            x->parent->leftChild = y;
-        else
-            x->parent->rightChild = y;
-        y->rightChild = x;
-        x->parent = y;
-        return;
-    }
-}

test/SortTimes.txt

@@ -0,0 +1,30 @@
+IS15 took 0.000852521 s
+MS15 took 0.0142171 s
+HS15 took 0.0216508 s
+IS30 took 0.00166257 s
+MS30 took 0.0296301 s
+HS30 took 0.0466942 s
+IS45 took 0.0025043 s
+MS45 took 0.0466391 s
+HS45 took 0.0730432 s
+IS60 took 0.00331285 s
+MS60 took 0.0630209 s
+HS60 took 0.10038 s
+IS75 took 0.00414368 s
+MS75 took 0.0804194 s
+HS75 took 0.129151 s
+IS90 took 0.00511297 s
+MS90 took 0.09825 s
+HS90 took 0.161143 s
+IS105 took 0.00584393 s
+MS105 took 0.121123 s
+HS105 took 0.191739 s
+IS120 took 0.00668049 s
+MS120 took 0.136146 s
+HS120 took 0.216863 s
+IS135 took 0.00745027 s
+MS135 took 0.152574 s
+HS135 took 0.245755 s
+IS150 took 0.00832467 s
+MS150 took 0.175396 s
+HS150 took 0.285888 s