3rd semester files

3rd-Semester-Fall-2022/PDS/Homework08/.vscode/settings.json

@@ -0,0 +1,33 @@
+{
+    "files.associations": {
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp"
+    }
+}

3rd-Semester-Fall-2022/PDS/Homework08/HW08_Input.txt

@@ -0,0 +1,4 @@
+14 54 34 67 89 56 43 12 21 23 98 31 52 74 93
+4 54 89 34 21
+5 54 23 10 93 12
+

3rd-Semester-Fall-2022/PDS/Homework08/Makefile

@@ -0,0 +1,45 @@
+TARGET_EXEC ?= a.out
+
+BUILD_DIR ?= ./build
+SRC_DIRS ?= ./src
+
+SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c -or -name *.s)
+OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
+DEPS := $(OBJS:.o=.d)
+
+INC_DIRS := $(shell find $(SRC_DIRS) -type d)
+INC_FLAGS := $(addprefix -I,$(INC_DIRS))
+
+CPPFLAGS ?= $(INC_FLAGS) -MMD -MP
+
+$(BUILD_DIR)/$(TARGET_EXEC): $(OBJS)
+	$(CXX) $(OBJS) -o $@ $(LDFLAGS)
+
+# assembly
+$(BUILD_DIR)/%.s.o: %.s
+	$(MKDIR_P) $(dir $@)
+	$(AS) $(ASFLAGS) -c $< -o $@
+
+# c source
+$(BUILD_DIR)/%.c.o: %.c
+	$(MKDIR_P) $(dir $@)
+	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
+
+# c++ source
+$(BUILD_DIR)/%.cpp.o: %.cpp
+	$(MKDIR_P) $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@
+
+
+.PHONY: clean
+
+clean:
+	$(RM) -r $(BUILD_DIR)
+
+-include $(DEPS)
+
+MKDIR_P ?= mkdir -p
+
+run:
+	make
+	./build/$(TARGET_EXEC)

3rd-Semester-Fall-2022/PDS/Homework08/build/src/HW07_Aidan_Sharpe.cpp.d

@@ -0,0 +1 @@
+build/./src/HW07_Aidan_Sharpe.cpp.o: src/HW07_Aidan_Sharpe.cpp

3rd-Semester-Fall-2022/PDS/Homework08/src/HW07_Aidan_Sharpe.cpp

@@ -0,0 +1,124 @@
+/****************************************************************
+* Name: Aidan Sharpe
+* Course: Principles of Data Structures
+* Class: CS04225
+* Assignment Date: November 07, 2022
+* File Name: HW07_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_IntBinaryTree.h"
+
+/// @brief Read data from a file into a binary tree
+/// @param tree binary tree to read into
+/// @param removals list of items to remove from binary tree
+/// @param searchTerms list of items to search tree for
+/// @param hasMetadata whether or not each line's first entry is the entry count
+/// @param fname file to read from
+void ReadBTFromFile(IntBinaryTree *tree, std::vector<int> *removals, std::vector<int> *searchTerms, bool hasMetadata, std::string fname);
+
+int main()
+{
+	IntBinaryTree binTree = IntBinaryTree();
+	std::vector<int> removals;
+	std::vector<int> searchTerms;
+	char hasMetadataAnswer;
+	bool hasMetadata;
+	std::string fname;
+	std::cout << "Data file name and path relative to Makefile:\n";
+	std::cin >> fname;
+	std::cout << "Does data set contain metadata? [y/N]\n";
+	std::cin >> hasMetadataAnswer; 
+	hasMetadata = tolower(hasMetadataAnswer) == 'y';
+
+	ReadBTFromFile(&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;
+
+	
+	return 0;
+}
+
+void ReadBTFromFile(IntBinaryTree *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();
+}

3rd-Semester-Fall-2022/PDS/Homework08/src/PDS_IntBinaryTree.h

@@ -0,0 +1,320 @@
+#pragma once
+#include <iostream>
+
+class IntBinaryTree
+{
+private:
+   int nodeCount, sum;
+   float mean;
+
+   // The TreeNode struct is used to build the tree.
+   struct TreeNode
+   {
+      int value;
+      TreeNode *left;
+      TreeNode *right;
+      TreeNode(int 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, int 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 += 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
+    int 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
+   int 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, int 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 -= 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.
+   IntBinaryTree()        // Constructor
+   {
+      root = nullptr;
+      nodeCount = 0;
+      sum = 0;
+      mean = 0;
+   }
+   ~IntBinaryTree()        // Destructor
+   {
+      destroySubtree(root);
+   }
+   void insert(int num)
+   {
+      insert(root, num);
+   }
+   void remove(int 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);
+   }
+   int getMin()
+   {
+      findMin(root);
+   }
+   int getMax()
+   {
+      findMax(root);
+   }
+   int getNodeCount()
+   {
+      return nodeCount;
+   }
+   int 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(int 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;
+    }
+};