Reorganize files

cpp/datastructs/circlesinglelist/Makefile

@@ -0,0 +1,23 @@
+CXX=g++
+CXXFLAGS=-g -Wall
+
+###############################################################################
+# Driver
+###############################################################################
+
+driver:	driver.cpp	circlesinglelist.o
+	${CXX} ${CXXFLAGS} driver.cpp circlesinglelist.o -o driver
+
+###############################################################################
+# CircleSingleList
+###############################################################################
+
+circlesinglelist.o:	circlesinglelist.cpp circlesinglelist.h
+	${CXX} ${CXXFLAGS} -c circlesinglelist.cpp -o circlesinglelist.o
+
+###############################################################################
+# Clean
+###############################################################################
+
+clean:
+	rm -f *.o driver

cpp/datastructs/circlesinglelist/circlesinglelist.cpp

@@ -0,0 +1,401 @@
+/*#############################################################################
+## Author: Shaun Reed                                                        ##
+## Legal: All Content (c) 2020 Shaun Reed, all rights reserved               ##
+## About: An example of a circular singly linked list                        ##
+##                                                                           ##
+## Contact: shaunrd0@gmail.com  | URL: www.shaunreed.com | GitHub: shaunrd0  ##
+##############################################################################
+## circlesinglelist.cpp
+*/
+
+#include "circlesinglelist.h"
+
+
+/******************************************************************************
+ * Constructors, Destructors, Operators
+ *****************************************************************************/
+
+/** copy constructor
+ * @brief Construct a new CircleSingleList::CircleSingleList object from an existing one
+ *
+ * @param rhs CircleSingleList object
+ */
+CircleSingleList::CircleSingleList(const CircleSingleList& rhs)
+{
+  Node *cp = rhs.tail;
+  Node *tempTail;
+  if (cp == NULL) tail = NULL;
+  else {
+    tail = new Node(cp->data);
+    tempTail = tail;
+    while (cp->next != NULL) {
+      cp = cp->next;
+      tail->next = new Node(cp->data);
+      tail = tail->next;
+    }
+    tail = tempTail;
+  }
+}
+
+/** operator=
+ * @brief Deep copy of the rhs CircleSingleList object
+ *        Pass rhs by value to create local copy, swap its data with our tail
+ *        Swapped local copy now with previous tail data deleted at end of scope using destr
+ *
+ * @param rhs CircleSingleList object
+ * @return CircleSingleList& A deep copy of the rhs CircleSingleList
+ */
+CircleSingleList CircleSingleList::operator=(CircleSingleList rhs)
+{
+  if (this == &rhs) return *this;
+  else std::swap(tail, rhs.tail);
+  return *this;
+}
+
+/** destructor
+ * @brief Destroy the CircleSingleList::CircleSingleList object
+ */
+CircleSingleList::~CircleSingleList()
+{
+  makeEmpty();
+}
+
+
+/******************************************************************************
+ * Public Member Functions
+ *****************************************************************************/
+
+/** insert
+ * @brief Inserts a value to the head of our linked list
+ *
+ * @param x The value to be inserted
+ */
+bool CircleSingleList::insert(int val)
+{
+  bool inserted = insert(val, tail);
+  if (inserted)  std::cout << "[" << val << "] was inserted into the list\n";
+  else std::cout << "[" << val << "] could not be inserted into the list\n";
+  return inserted;
+}
+
+/** insert at
+ * @brief Inserts a value in the place of a given key
+ *        Key Node found is moved to the newNode->next positon
+ *
+ * @param key The value to search for to determine insert location
+ * @param val The value to be inserted into the list
+ */
+bool CircleSingleList::insert(int val, int key)
+{
+  if (isEmpty()) {
+    std::cout << "Cannot insert at an existing value using an empty list...\n";
+    return false;
+  }
+
+  bool inserted = insert(val, key, tail);
+  if (inserted) std::cout << "[" << val << "] was inserted into the list\n";
+  else std::cout << "[" << val << "] could not be inserted into the list\n";
+  return inserted;
+}
+
+/** remove
+ * @brief Removes a value in the list by calling a private member and handling output
+ *
+ * @param val Value to be removed from the list
+ * @return true If the value was removed from the list
+ * @return false If the value was not removed from the list
+ */
+bool CircleSingleList::remove(int val)
+{
+  if (isEmpty()) {
+    std::cout << "Cannot remove any values from an empty list...\n";
+    return false;
+  }
+
+  bool removed = remove(val, tail);
+  if (removed) std::cout << "[" << val << "] was removed from the list\n";
+  else std::cout << "[" << val << "] could not be removed from the list\n";
+  return removed;
+}
+
+/** replace
+ * @brief Replaces a value in the list by calling a private member and handling output
+ *
+ * @param val Value to insert into the list
+ * @param key Value to be replaced within the list
+ * @return true If the key has been replaced in the list by val
+ * @return false If the key has not been replaced in the list by val
+ */
+bool CircleSingleList::replace(int val, int key)
+{
+  if (isEmpty()) {
+    std::cout << "Cannot replace any values from an empty list...\n";
+    return false;
+  }
+
+  bool replaced = replace(val, key, tail);
+  if (replaced) std::cout << "[" << key << "] was replaced by "
+    << "[" << val << "] in the list\n";
+  else std::cout << "[" << key << "] could not be replaced by "
+    << "[" << val << "] in the list\n";
+  return replaced;
+}
+
+/** makeEmpty
+ * @brief Empty this CircleSingleList object, deleting all associated Nodes
+ */
+void CircleSingleList::makeEmpty()
+{
+  Node *nextNode, *temp;
+
+  // If the list is empty
+  if (tail == NULL) return;
+
+  // If the list has members other than itself, keep a pointer to them
+  if (tail != tail->next) nextNode = tail->next;
+  // Delete the list nodes until we hit the tail
+  while(nextNode != tail) {
+    // Save pointer to delete previous node
+    temp = nextNode;
+    // Move to the next node
+    nextNode = nextNode->next;
+    // Delete the previous node and set it to NULL
+    delete temp;
+    temp = NULL;
+  }
+
+  // Always delete the tail node and set it to NULL
+  delete tail;
+  tail = NULL;
+}
+
+/** isEmpty
+ * @brief Determine if the CircleSingleList is empty
+ *
+ * @return true If the CircleSingleList::tail is NULL
+ * @return false If the CircleSingleList::tail contains data
+ */
+bool CircleSingleList::isEmpty() const
+{
+  return tail == NULL;
+}
+
+/** peek
+ * @brief return the value at the head of the list
+ *
+ * @return int The value held at the Node at the head of our linked list
+ */
+int CircleSingleList::peek() const
+{
+  // If there is only one data member, a circular list node will point to itself
+  if (!isEmpty())
+    std::cout << "[" << tail->next->data << "] is at the top of our list\n";
+  else std::cout << "Nothing to peek, our list is empty...\n";
+  return tail->next->data;
+}
+
+/** print
+ * @brief Output the data held by the CircleSingleList object
+ *        Calls to the private print()
+ */
+void CircleSingleList::print() const
+{
+  // Print the list starting from the head node
+  if(!isEmpty()) print(tail->next);
+  else std::cout << "Nothing to print, our list is empty...\n";
+}
+
+/** find
+ * @brief Calls to the private member find() and handles return cases
+ *
+ * @param val The value to search for within our CircleSingleList
+ * @return true If the value was found in this CircleSingleList
+ * @return false If the value was not found in this CircleSingleList
+ */
+bool CircleSingleList::find(int val) const
+{
+  Node *result = find(val, tail);
+  if( result == NULL) {
+    std::cout << "[" << val << "] Was not found in our list\n";
+    return false;
+  }
+
+  std::cout << "[" << result->data << "] Was found in our list\n";
+  return true;
+}
+
+
+/******************************************************************************
+ * Private Member Functions
+ *****************************************************************************/
+
+/** insert
+ * @brief Private member to handle inserting value into the list
+ *
+ * @param val Value to be inserted
+ * @param tail The tail of the list to insert the value into
+ * @return true If the value was inserted
+ * @return false If the value could not be inserted
+ */
+bool CircleSingleList::insert(int val, Node *&tail)
+{
+  Node *newNode = new Node(val);
+  // If the list is not empty, update next pointer to head node
+  if (!isEmpty()) newNode->next = tail->next;
+  else tail = newNode;
+  // Always set head to our newNode
+  tail->next = newNode;
+  return true;
+}
+
+/** insert at
+ * @brief Private member to handle inserting a value at a key within our list
+ *
+ * @param val Value to be inserted
+ * @param key Key value to search for within the list
+ * @param tail Tail node of the list to insert to
+ * @return true If the value was inserted
+ * @return false If the value was not inserted
+ */
+bool CircleSingleList::insert(int val, int key, Node *&tail)
+{
+  Node *newNode = new Node(val);
+  if (isEmpty()) return false;
+  // Let insert() handle inserting at the head
+  else if (tail->next->data == key) return insert(val);
+
+  Node *keyNode = findPrevious(key);
+  // If there was no keyNode found, the key does is not in our list
+  // Don't insert anything, return false and let caller decide whats next
+  if (keyNode == NULL) return false;
+  // Set the newNode to come between the keyNode and the Node we are inserting at
+  // [keyNode]->[next]
+  // [keyNode]->[newNode]->[next]
+  // Where (keyNode->next->data == key) and keyNode is given by findPrevious()
+  newNode->next = keyNode->next;
+  keyNode->next = newNode;
+  return true;
+}
+
+/** remove
+ * @brief Private member to remove values from the list
+ *
+ * @param val Value to be removed
+ * @param tail Tail of the list to remove the value from
+ * @return true If the value has been removed from the list
+ * @return false If the value has not been removed from the list
+ */
+bool CircleSingleList::remove(int val, Node *&tail)
+{
+  Node *exile, *tempHead;
+  Node *prevNode = findPrevious(val);
+  // If findPrevious returns NULL, the value was not found
+  if (prevNode == NULL) return false;
+
+  // If the node found is the only member of the list
+  if (prevNode == prevNode->next) {
+    // Delete, reset list to NULL
+    delete tail;
+    tail = NULL;
+    return true;
+  }
+  // If the node to remove is the tail and the list has > 1 members
+  else if (prevNode->next == tail) {
+    tempHead = tail->next;
+    exile = prevNode->next;
+    // Create the new tail
+    tail = prevNode;
+    // Link the head Node, skipping over the exile Node
+    tail->next = tempHead;
+  }
+  else {
+    // Get a ptr to the member we are removing from the list
+    exile = prevNode->next;
+    // Relink the list, skipping the exile node
+    prevNode->next = prevNode->next->next;
+  }
+
+  // Delete the dangling ptr to the exile Node we removed from the list
+  delete exile;
+  exile = NULL;
+  return true;
+}
+
+/** replace
+ * @brief Private member to replace values within the list
+ *
+ * @param val Value to insert into the list
+ * @param key Value to be replaced within the list
+ * @param tail Tail of the list to replace the value
+ * @return true If the key has been replaced by val within the list
+ * @return false If the key has not been replaced by val within the list
+ */
+bool CircleSingleList::replace(int val, int key, Node *&tail)
+{
+  Node *replacee = find(key, tail);
+  if (replacee == NULL) return false;
+  replacee->data = val;
+  return true;
+}
+
+/** find
+ * @brief Find and return a Node which contains the given value
+ *
+ * @param val The value to search for within our CircleSingleList
+ * @param start The Node to begin the search at within the linked list, usually the head node
+ * @return CircleSingleList::Node* A pointer to the Node containing the search value
+ */
+CircleSingleList::Node* CircleSingleList::find(int val, Node *start) const
+{
+  // Check the first Node, return if it is the value requested
+  if (start->data == val) return start;
+  Node *foundNode = start->next;
+  // Move through the list, checking each member until we reach the start Node
+  while (foundNode != start) {
+    if (foundNode->data == val) return foundNode;
+    foundNode = foundNode->next;
+  }
+  // If we have not yet returned a foundNode, the key is not in our list
+  return NULL;
+}
+
+/** findPrevious
+ * @brief Find and return the Node before a given value
+ *
+ * @param val The value to search for within our CircleSingleList
+ * @return CircleSingleList::Node* A pointer to the Node previous to the  given value
+ */
+CircleSingleList::Node* CircleSingleList::findPrevious(int val) const
+{
+  if (isEmpty()) return NULL;
+  else if (tail->next->data == val) return tail;
+
+  // Create temp ptr to the head of our list
+  Node *tempHead = tail->next;
+  // Move through the list until we reach the head node again
+  while (tempHead->next != tail->next) {
+    // Check the value within the next node, if found return it
+    if (tempHead->next->data == val) return tempHead;
+    else tempHead = tempHead->next;
+  }
+
+  return NULL;
+}
+
+/** print
+ * @brief Output the contents of a CircleSingleList until we hit a matching node
+ *
+ * @param start The Node to begin traversing output from
+ */
+void CircleSingleList::print(Node *start) const
+{
+  Node *temp = start;
+  std::cout << "List Contents: " << temp->data << " | ";
+  temp = temp->next;
+  // Until we reach the start node again, print the list contents
+  while (temp != start) {
+    std::cout << temp->data << " | ";
+    temp = temp->next;
+  }
+  std::cout << std::endl;
+}

cpp/datastructs/circlesinglelist/circlesinglelist.h

@@ -0,0 +1,49 @@
+/*#############################################################################
+## Author: Shaun Reed                                                        ##
+## Legal: All Content (c) 2020 Shaun Reed, all rights reserved               ##
+## About: An example of a circular singly linked list                        ##
+##                                                                           ##
+## Contact: shaunrd0@gmail.com  | URL: www.shaunreed.com | GitHub: shaunrd0  ##
+##############################################################################
+## circlesinglelist.h
+*/
+
+#ifndef CIRCLESINGLELIST_H
+#define CIRCLESINGLELIST_H
+
+#include <iostream>
+
+class CircleSingleList {
+  public:
+    CircleSingleList() : tail(NULL) {};
+    CircleSingleList(const CircleSingleList& rhs);
+    CircleSingleList operator=(CircleSingleList rhs);
+    ~CircleSingleList();
+    bool insert(int val);
+    bool insert(int val, int key);
+    bool remove(int val);
+    bool replace(int val, int key);
+    void makeEmpty();
+    bool isEmpty() const;
+    int peek() const;
+    void print() const;
+    bool find(int val) const;
+
+  private:
+    struct Node {
+      int data;
+      Node *next;
+      Node(): data(), next(NULL) {};
+      Node(int val): data(val), next(this) {};
+    };
+    Node *tail;
+    bool insert(int val, Node *&tail);
+    bool insert(int val, int key, Node *&tail);
+    bool remove(int val, Node *&tail);
+    bool replace(int val, int key, Node *&tail);
+    Node* find(int val, Node *start) const;
+    Node* findPrevious(int val) const;
+    void print(Node *start) const;
+};
+
+#endif

cpp/datastructs/circlesinglelist/driver.cpp

@@ -0,0 +1,106 @@
+/*#############################################################################
+## Author: Shaun Reed                                                        ##
+## Legal: All Content (c) 2020 Shaun Reed, all rights reserved               ##
+## About: A driver program to test a circular singly linked list             ##
+##                                                                           ##
+## Contact: shaunrd0@gmail.com  | URL: www.shaunreed.com | GitHub: shaunrd0  ##
+##############################################################################
+## driver.cpp
+*/
+
+#include "circlesinglelist.h"
+#include <iostream>
+
+enum OPS {
+  EXIT, INSERT, INSERTAT, EMPTY, PEEK, PRINT, FIND, REMOVE, REPLACE
+};
+
+int main()
+{
+  std::cout << "Driver: \n";
+
+  CircleSingleList testList;
+  bool exit = false;
+  int choice = -1;
+  int val, key;
+
+  while (!exit)
+  {
+    std::cout << "##### Circular Singly Linked List Menu #####\n\t0. Exit"
+      << "\n\t1. Insert\n\t2. Insert at\n\t3. Empty list\n\t4. Peek top of list"
+      << "\n\t5. Print list\n\t6. Find\n\t7. Remove\n\t8. Replace\n";
+    std::cin >> choice;
+    std::cin.clear();
+    switch (choice) {
+    case EXIT:
+      exit = true;
+      break;
+
+    case INSERT:
+      std::cout << "Enter a value to add to our list: ";
+      std::cin >> val;
+      std::cin.clear();
+      testList.insert(val);
+      break;
+
+    case INSERTAT:
+      std::cout << "Enter a new value to add to our list: ";
+      std::cin >> val;
+      std::cin.clear();
+      std::cout << "Enter an existing value to insert at within our list: ";
+      std::cin >> key;
+      std::cin.clear();
+      if (testList.insert(val, key)) {
+        std::cout << "List after inserting ["
+          << val << "] at [" << key << "]: \n";
+        testList.print();
+      }
+      break;
+
+    case EMPTY:
+      testList.makeEmpty();
+      break;
+
+    case PEEK:
+      testList.peek();
+      break;
+
+    case PRINT:
+      testList.print();
+      break;
+
+    case FIND:
+      std::cout << "Enter an existing value to search for within our list: ";
+      std::cin >> val;
+      std::cin.clear();
+      testList.find(val);
+      break;
+
+    case REMOVE:
+      std::cout << "Enter an existing value to remove from our list: ";
+      std::cin >> val;
+      std::cin.clear();
+      testList.remove(val);
+      break;
+
+    case REPLACE:
+      std::cout << "Enter a new value to add to our list: ";
+      std::cin >> val;
+      std::cin.clear();
+      std::cout << "Enter an existing value to replace within our list: ";
+      std::cin >> key;
+      std::cin.clear();
+      if (testList.replace(val, key)) {
+        std::cout << "List after replacing ["
+          << key << "] by [" << val << "]: \n";
+        testList.print();
+      }
+      break;
+
+    default:
+      std::cout << "Invalid entry...\n";
+      break;
+    }
+  }
+}
+