Adog64/Rowan-Classes
1
0
Fork 0
Code Issues 4 Pull Requests Packages Projects 1 Releases Wiki Activity

3rd semester files

Browse Source
This commit is contained in:
Adog64
2024-02-22 14:26:13 -05:00
parent cd78e4d51b
commit 80a59b57a1
280 changed files with 220686 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
3rd-Semester-Fall-2022/PDS/HomeworkEC/src/ECHW_Aidan_Sharpe.cpp Executable file
View File

@@ -0,0 +1,297 @@
/****************************************************************
* Name: Aidan Sharpe
* Course: Principles of Data Structures
* Class: CS04225
* Assignment Date: November 07, 2022
* File Name: ECHW_Aidan_Sharpe.cpp
*****************************************************************
* ID: Homework 7 Problem 1
* Purpose: Read values into a binary tree and show the data in several ways
*****************************************************************/
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include "PDS_BinaryTree.h"
void ReadBTIntFromFile(BinaryTree<int> *tree, std::vector<int> *removals, std::vector<int> *searchTerms, bool hasMetadata, std::string fname);
void ReadBTCharFromFile(BinaryTree<char> *tree, std::vector<char> *removals, std::vector<char> *searchTerms, bool hasMetadata, std::string fname);
void ReadBTDoubleFromFile(BinaryTree<double> *tree, std::vector<double> *removals, std::vector<double> *searchTerms, bool hasMetadata, std::string fname);
int main()
{
char type;
std::string fname;
char hasMetadataAnswer;
bool hasMetadata;
std::cout << "Path of data file relative to Makefile.\n";
std::cin >> fname;
std::cout << "Enter type of data. I for ints, C for chars, D for doubles.\n";
std::cin >> type;
std::cout << "Does data set contain metadata? [y/N]\n";
std::cin >> hasMetadataAnswer;
hasMetadata = tolower(hasMetadataAnswer) == 'y';
if (type == 'C')
{
BinaryTree<char> binTree = BinaryTree<char>();
std::vector<char> removals;
std::vector<char> searchTerms;
ReadBTCharFromFile(&binTree, &removals, &searchTerms, hasMetadata, fname);
std::cout << "In Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nRemoving values";
for (char removal : removals)
{
std::cout << ' ' << removal;
binTree.remove(removal);
}
std::cout << "\nIn Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nSearching for values:\n";
for(char term : searchTerms)
std::cout << term << ((binTree.search(term)) ? " found" : " not found") << std::endl;
}
else if(type == 'I')
{
BinaryTree<int> binTree = BinaryTree<int>();
std::vector<int> removals;
std::vector<int> searchTerms;
ReadBTIntFromFile(&binTree, &removals, &searchTerms, hasMetadata, fname);std::cout << "In Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nRemoving values";
for (int removal : removals)
{
std::cout << ' ' << removal;
binTree.remove(removal);
}
std::cout << "\nIn Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nSearching for values:\n";
for(int term : searchTerms)
std::cout << term << ((binTree.search(term)) ? " found" : " not found") << std::endl;
}
else if(type == 'D')
{
BinaryTree<double> binTree = BinaryTree<double>();
std::vector<double> removals;
std::vector<double> searchTerms;
ReadBTDoubleFromFile(&binTree, &removals, &searchTerms, hasMetadata, fname);
std::cout << "In Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nRemoving values";
for (double removal : removals)
{
std::cout << ' ' << removal;
binTree.remove(removal);
}
std::cout << "\nIn Order: ";
binTree.showInOrder();
std::cout << "\nPre-Order: ";
binTree.showPreOrder();
std::cout << "\nPost-Order: ";
binTree.showPostOrder();
std::cout << "\nLeaf Nodes: ";
binTree.showLeafNodes();
std::cout << "\nMax: " << binTree.getMax();
std::cout << "\nMin: " << binTree.getMin();
std::cout << "\nNode Count: " << binTree.getNodeCount();
std::cout << "\nSum: " << binTree.getSum();
std::cout << "\nMean: " << binTree.getMean();
std::cout << "\nSearching for values:\n";
for(double term : searchTerms)
std::cout << term << ((binTree.search(term)) ? " found" : " not found") << std::endl;
}
else
std::cout << "Selection " << type << " does not signify any valid type.\n";
return 0;
}
void ReadBTIntFromFile(BinaryTree<int> *tree, std::vector<int> *removals, std::vector<int> *searchTerms, bool hasMetadata, std::string fname)
{
std::ifstream infile;
std::string line;
infile.open(fname);
bool isFirstEntry;
int lineNum = 0;
while (std::getline(infile, line))
{
isFirstEntry = true;
std::string snum;
for (int i = 0; i < line.length(); i++)
{
if (isdigit(line.at(i)))
snum.push_back(line.at(i));
if (line.at(i) == ' ' || i == line.length() - 1)
{
if (!(hasMetadata && isFirstEntry))
{
switch (lineNum)
{
case 0:
tree->insert(std::stoi(snum));
break;
case 1:
removals->push_back(std::stoi(snum));
break;
case 2:
searchTerms->push_back(std::stoi(snum));
break;
}
}
snum = "";
isFirstEntry = false;
}
}
lineNum++;
}
infile.close();
}
void ReadBTCharFromFile(BinaryTree<char> *tree, std::vector<char> *removals, std::vector<char> *searchTerms, bool hasMetadata, std::string fname)
{
std::ifstream infile;
std::string line;
infile.open(fname);
int lineNum = 0;
bool isFirstEntry;
char c;
while (std::getline(infile, line))
{
isFirstEntry = true;
for (int i = 0; i < line.length(); i++)
{
if (line.at(i) != ' ')
c = line.at(i);
if (line.at(i) == ' ' || i == line.length() - 1)
{
if (!(hasMetadata && isFirstEntry))
{
switch (lineNum)
{
case 0:
tree->insert(c);
break;
case 1:
removals->push_back(c);
break;
case 2:
searchTerms->push_back(c);
break;
}
}
isFirstEntry = false;
}
}
lineNum++;
}
infile.close();
}
void ReadBTDoubleFromFile(BinaryTree<double> *tree, std::vector<double> *removals, std::vector<double> *searchTerms, bool hasMetadata, std::string fname)
{
std::ifstream infile;
std::string line;
infile.open(fname);
int lineNum = 0;
bool isFirstEntry;
while (std::getline(infile, line))
{
isFirstEntry = true;
std::string snum;
for (int i = 0; i < line.length(); i++)
{
if (isdigit(line.at(i)) || line.at(i) == '.')
snum.push_back(line.at(i));
if (line.at(i) == ' ' || i == line.length() - 1)
{
if (!(hasMetadata && isFirstEntry))
{
switch (lineNum)
{
case 0:
tree->insert(std::stod(snum));
break;
case 1:
removals->push_back(std::stod(snum));
break;
case 2:
searchTerms->push_back(std::stod(snum));
break;
}
}
snum = "";
isFirstEntry = false;
}
}
lineNum++;
}
infile.close();
}

322
3rd-Semester-Fall-2022/PDS/HomeworkEC/src/PDS_BinaryTree.h Executable file
View File

@@ -0,0 +1,322 @@
#pragma once
#include <iostream>
template <class T>
class BinaryTree
{
private:
int nodeCount;
float sum;
float mean;
// The TreeNode struct is used to build the tree.
struct TreeNode
{
T value;
TreeNode *left;
TreeNode *right;
TreeNode(T value1,
TreeNode *left1 = nullptr,
TreeNode *right1 = nullptr)
{
value = value1;
left = left1;
right = right1;
}
};
TreeNode *root; // Pointer to the root of the tree
//**************************************************
// This version of insert inserts a number into *
// a given subtree of the main binary search tree. *
//**************************************************
void insert(TreeNode * &tree, T num)
{
// If the tree is empty, make a new node and make it
// the root of the tree. We are passing the node pointer by
// reference so that if it is replaced like below, the
// change will also impact the incoming argument.
if (!tree)
{
tree = new TreeNode(num);
nodeCount++;
sum += static_cast<float>(num);
mean = static_cast<float>(sum)/nodeCount;
return; //Terminate the function
}
// If num is already in tree: return.
if (tree->value == num)
return;
// The tree is not empty: insert the new node into the
// left or right subtree.
if (num < tree->value)
insert(tree->left, num);
else
insert(tree->right, num);
}
/// @brief find the minimum value in an integer binary tree
/// @param tree the binary tree to traverse
/// @return the minimum value
T findMin(TreeNode *tree)
{
if (!tree)
throw std::length_error("Empty set has no min.");
else
{
TreeNode *leftest = tree;
while (leftest->left)
leftest = leftest->left;
return leftest->value;
}
}
/// @brief find the maximum value in an integer binary tree
/// @param tree the binary tree to traverse
/// @return the maximum value
T findMax(TreeNode *tree)
{
if (!tree)
throw std::length_error("Empty set has no max.");
else
{
TreeNode *rightest = tree;
while (rightest->right)
rightest = rightest->right;
return rightest->value;
}
}
//***************************************************
// destroySubTree is called by the destructor. It *
// deletes all nodes in the tree. *
//***************************************************
void destroySubtree(TreeNode *tree)
{
if (!tree) return;
destroySubtree(tree->left);
destroySubtree(tree->right);
// Delete the node at the root.
delete tree;
}
//********************************************
// remove deletes the node in the given tree *
// that has a value member the same as num. *
//********************************************
void remove(TreeNode *&tree, T num)
{
if (tree == nullptr) return;
if (num < tree->value)
remove(tree->left, num);
else if (num > tree->value)
remove(tree->right, num);
else
{
// We have found the node to delete.
nodeCount--;
sum -= static_cast<float>(num);
mean = static_cast<float>(sum)/nodeCount;
makeDeletion(tree);
}
}
//***********************************************************
// makeDeletion takes a reference to a tree whose root *
// is to be deleted. If the tree has a single child, the *
// the tree is replaced by the single child after the *
// removal of its root node. If the tree has two children *
// the left subtree of the deleted node is attached at *
// an appropriate point in the right subtree, and then *
// the right subtree replaces the original tree. *
//***********************************************************
void makeDeletion(TreeNode *&tree)
{
// Used to hold node that will be deleted.
TreeNode *nodeToDelete = tree;
// Used to locate the point where the
// left subtree is attached.
TreeNode *attachPoint;
if (tree->right == nullptr)
{
// Replace tree with its left subtree.
tree = tree->left;
}
else if (tree->left == nullptr)
{
// Replace tree with its right subtree.
tree = tree->right;
}
else
//The node has two children
{
// Move to right subtree.
attachPoint = tree->right;
// Locate the smallest node in the right subtree
// by moving as far to the left as possible.
while (attachPoint->left != nullptr)
attachPoint = attachPoint->left;
// Attach the left subtree of the original tree
// as the left subtree of the smallest node
// in the right subtree.
attachPoint->left = tree->left;
// Replace the original tree with its right subtree.
tree = tree->right;
}
// Delete root of original tree
delete nodeToDelete;
}
//*********************************************************
// This function displays the values stored in a tree *
// in inorder. *
//*********************************************************
void displayInOrder(TreeNode *tree) const
{
if (tree)
{
displayInOrder(tree->left);
std::cout << tree->value << " ";
displayInOrder(tree->right);
}
}
//*********************************************************
// This function displays the values stored in a tree *
// in inorder. *
//*********************************************************
void displayPreOrder(TreeNode *tree) const
{
if (tree)
{
std::cout << tree->value << " ";
displayPreOrder(tree->left);
displayPreOrder(tree->right);
}
}
//*********************************************************
// This function displays the values stored in a tree *
// in postorder. *
//*********************************************************
void displayPostOrder(TreeNode *tree) const
{
if (tree)
{
displayPostOrder(tree->left);
displayPostOrder(tree->right);
std::cout << tree->value << " ";
}
}
/// @brief Displays the leaf values of a binary tree
/// @param tree Binary tree being traced recursively
void displayLeafNodes(TreeNode *tree) const
{
if (tree)
{
if(tree->left || tree->right)
{
displayLeafNodes(tree->left);
displayLeafNodes(tree->right);
}
else
std::cout << tree->value << ' ';
}
}
public:
// These member functions are the public interface.
BinaryTree() // Constructor
{
root = nullptr;
nodeCount = 0;
sum = 0;
mean = 0;
}
~BinaryTree() // Destructor
{
destroySubtree(root);
}
void insert(T num)
{
insert(root, num);
}
void remove(T num)
{
remove(root, num);
}
void showInOrder(void) const
{
displayInOrder(root);
}
void showPreOrder() const
{
displayPreOrder(root);
}
void showPostOrder() const
{
displayPostOrder(root);
}
void showLeafNodes() const
{
displayLeafNodes(root);
}
T getMin()
{
findMin(root);
}
T getMax()
{
findMax(root);
}
int getNodeCount()
{
return nodeCount;
}
float getSum()
{
return sum;
}
float getMean()
{
return mean;
}
//***************************************************
// searchNode determines if a value is present in *
// the tree. If so, the function returns true. *
// Otherwise, it returns false. *
//***************************************************
bool search(T num) const
{
TreeNode *tree = root;
while (tree)
{
if (tree->value == num)
return true;
else if (num < tree->value)
tree = tree->left;
else
tree = tree->right;
}
return false;
}
};