From 87b3f5a394cfbc8de47812f8c80a3517032bd321 Mon Sep 17 00:00:00 2001 From: Shaun Reed Date: Thu, 30 Apr 2020 15:01:14 -0400 Subject: [PATCH] RD of circular singly linked list --- plates/circlesinglelist/Makefile | 10 +- plates/circlesinglelist/circlesinglelist.cpp | 313 +++++++++++-------- plates/circlesinglelist/circlesinglelist.h | 37 +-- plates/circlesinglelist/driver.cpp | 12 +- 4 files changed, 211 insertions(+), 161 deletions(-) diff --git a/plates/circlesinglelist/Makefile b/plates/circlesinglelist/Makefile index dde1fa7..97845a3 100644 --- a/plates/circlesinglelist/Makefile +++ b/plates/circlesinglelist/Makefile @@ -5,15 +5,15 @@ CXXFLAGS=-g -Wall # Driver ############################################################################### -driver: driver.cpp singlelist.o - ${CXX} ${CXXFLAGS} driver.cpp singlelist.o -o driver +driver: driver.cpp circlesinglelist.o + ${CXX} ${CXXFLAGS} driver.cpp circlesinglelist.o -o driver ############################################################################### -# SingleList +# CircleSingleList ############################################################################### -singlelist.o: singlelist.cpp singlelist.h - ${CXX} ${CXXFLAGS} -c singlelist.cpp -o singlelist.o +circlesinglelist.o: circlesinglelist.cpp circlesinglelist.h + ${CXX} ${CXXFLAGS} -c circlesinglelist.cpp -o circlesinglelist.o ############################################################################### # Clean diff --git a/plates/circlesinglelist/circlesinglelist.cpp b/plates/circlesinglelist/circlesinglelist.cpp index d4b2a75..a876c13 100644 --- a/plates/circlesinglelist/circlesinglelist.cpp +++ b/plates/circlesinglelist/circlesinglelist.cpp @@ -1,78 +1,79 @@ /*############################################################################# ## Author: Shaun Reed ## ## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ## -## About: An example of a singly linked list ## +## About: An example of a circular singly linked list ## ## ## ## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ## ############################################################################## -## singlelist.cpp +## circlesinglelist.cpp */ -#include "singlelist.h" +#include "circlesinglelist.h" + /****************************************************************************** * Constructors, Destructors, Operators - *****************************************************************************/ + *****************************************************************************/ /** copy constructor - * @brief Construct a new SingleList::SingleList object from an existing one - * - * @param rhs SingleList object + * @brief Construct a new CircleSingleList::CircleSingleList object from an existing one + * + * @param rhs CircleSingleList object */ -SingleList::SingleList(const SingleList& rhs) +CircleSingleList::CircleSingleList(const CircleSingleList& rhs) { - Node *cp = rhs.head; - Node *tempHead; - if (cp == NULL) head = NULL; + Node *cp = rhs.tail; + Node *tempTail; + if (cp == NULL) tail = NULL; else { - head = new Node(cp->data); - tempHead = head; + tail = new Node(cp->data); + tempTail = tail; while (cp->next != NULL) { cp = cp->next; - head->next = new Node(cp->data); - head = head->next; + tail->next = new Node(cp->data); + tail = tail->next; } - head = tempHead; + tail = tempTail; } } /** operator= - * @brief Assign two SingleList objects equal using copy constr and class destr - * Pass the rhs by value to create local copy, swap its contents - * Destructor called on previous SingleList data at the end of this scope - * - * @param rhs SingleList object passed by value - * @return SingleList A deep copy of the rhs SingleList object + * @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 */ -SingleList SingleList::operator=(SingleList rhs) +CircleSingleList CircleSingleList::operator=(CircleSingleList rhs) { if (this == &rhs) return *this; - std::swap(head, rhs.head); + else std::swap(tail, rhs.tail); return *this; } /** destructor - * @brief Destroy the SingleList::SingleList object + * @brief Destroy the CircleSingleList::CircleSingleList object */ -SingleList::~SingleList() +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 SingleList::insert(int val) +bool CircleSingleList::insert(int val) { - bool inserted = insert(val, head); - if (inserted) - std::cout << "[" << val << "] was inserted into the list\n"; + 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; } @@ -80,166 +81,196 @@ bool SingleList::insert(int val) /** 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 SingleList::insert(int val, int key) +bool CircleSingleList::insert(int val, int key) { - bool inserted = insert(val, key, head); - if (inserted) - std::cout << "[" << val << "] was inserted into the list\n"; + 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 SingleList::remove(int val) +bool CircleSingleList::remove(int val) { - bool removed = remove(val, head); - if (removed) - std::cout << "[" << val << "] was removed from the list\n"; + 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 SingleList::replace(int val, int key) +bool CircleSingleList::replace(int val, int key) { - bool replaced = replace(val, key, head); - 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"; + 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 SingleList object, deleting all associated Nodes + * @brief Empty this CircleSingleList object, deleting all associated Nodes */ -void SingleList::makeEmpty() +void CircleSingleList::makeEmpty() { Node *nextNode, *temp; - if (head == NULL) return; - nextNode = head->next; - delete head; - head = NULL; - while(nextNode != NULL) { + // 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 SingleList is empty - * - * @return true If the SingleList::head is NULL - * @return false If the SingleList::head contains data + * @brief Determine if the CircleSingleList is empty + * + * @return true If the CircleSingleList::tail is NULL + * @return false If the CircleSingleList::tail contains data */ -bool SingleList::isEmpty() const +bool CircleSingleList::isEmpty() const { - return head == NULL; + return tail == NULL; } /** peek - * @brief returns the value at the SingleList::head - * - * @return int The value held at the Node pointed to by SingleList::head + * @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 */ -void SingleList::peek() const +void CircleSingleList::peek() const { - if (!isEmpty()) - std::cout << "[" << head->data << "] is at the top of our list\n"; + // 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"; } /** print - * @brief Output the data held by the SingleList object + * @brief Output the data held by the CircleSingleList object * Calls to the private print() */ -void SingleList::print() const +void CircleSingleList::print() const { - if(!isEmpty()) print(head); + // 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 SingleList - * @return true If the value was found in this SingleList - * @return false If the value was not found in this SingleList + * + * @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 SingleList::find(int val) const +bool CircleSingleList::find(int val) const { - Node *result = find(val, head); + 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 head The head of the list to insert the value into + * @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 SingleList::insert(int val, Node *&head) +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 = head; + if (!isEmpty()) newNode->next = tail->next; + else tail = newNode; // Always set head to our newNode - head = 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 head Head node of the list to insert to + * @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 SingleList::insert(int val, int key, Node *&head) +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 (head->data == key) return insert(val); + else if (tail->next->data == key) return insert(val); - Node *keyNode = findPrevious(key, head); + 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 BEFORE our keyNode + // 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; @@ -247,41 +278,60 @@ bool SingleList::insert(int val, int key, Node *&head) /** remove * @brief Private member to remove values from the list - * + * * @param val Value to be removed - * @param head Head of the list to remove the value from + * @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 SingleList::remove(int val, Node *&head) +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 (head == NULL) return false; - else if (head->data == val) { - head = head->next; + // 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; + } - Node *prevNode = findPrevious(val, head); - if (prevNode == NULL) return false; - Node *gtfo = prevNode->next; - prevNode->next = prevNode->next->next; - delete gtfo; + // 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 head Head of the list to replace the value + * @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 SingleList::replace(int val, int key, Node *&head) +bool CircleSingleList::replace(int val, int key, Node *&tail) { - Node *replacee = find(key, head); + Node *replacee = find(key, tail); if (replacee == NULL) return false; replacee->data = val; return true; @@ -289,20 +339,20 @@ bool SingleList::replace(int val, int key, Node *&head) /** find * @brief Find and return a Node which contains the given value - * - * @param val The value to search for within our SingleList - * @return SingleList::Node* A pointer to the Node containing the search 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 */ -SingleList::Node* SingleList::find(int val, Node *start) const +CircleSingleList::Node* CircleSingleList::find(int val, Node *start) const { - // If given a NULL list, return NULL - // If given a head which contains the requested value, return the foundNode - if (start == NULL || start->data == val) return start; - - Node *foundNode = start; - while (foundNode->next != NULL) { - foundNode = foundNode->next; + // 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; @@ -310,34 +360,39 @@ SingleList::Node* SingleList::find(int val, Node *start) const /** findPrevious * @brief Find and return the Node before a given value - * - * @param val The value to search for within our SingleList - * @return SingleList::Node* A pointer to the Node previous to the 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 */ -SingleList::Node* SingleList::findPrevious(int val, Node *start) const +CircleSingleList::Node* CircleSingleList::findPrevious(int val) const { if (isEmpty()) return NULL; - else if (start->data == val) return start; + else if (tail->next->data == val) return tail; - Node *temp = start; - while (temp->next != NULL) { - if (temp->next->data == val) return temp; - temp = temp->next; + // 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 SingleList from the given Node to NULL - * + * @brief Output the contents of a CircleSingleList until we hit a matching node + * * @param start The Node to begin traversing output from */ -void SingleList::print(Node *start) const +void CircleSingleList::print(Node *start) const { Node *temp = start; - std::cout << "List Contents: "; - while (temp != NULL) { + 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; } diff --git a/plates/circlesinglelist/circlesinglelist.h b/plates/circlesinglelist/circlesinglelist.h index 24bcda2..4274e47 100644 --- a/plates/circlesinglelist/circlesinglelist.h +++ b/plates/circlesinglelist/circlesinglelist.h @@ -1,29 +1,24 @@ /*############################################################################# ## Author: Shaun Reed ## ## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ## -## About: An example of a singly linked list ## -## ## -## Structure: Remove: Insert: Insert at: Replace: ## -## o-o-o-o-o-o o-o--x-->o-o-o o o o ## -## | /| / \ ## -## o-o-o-o-o-o o-o~o-o-o-o o-o~x~o-o-o ## +## About: An example of a circular singly linked list ## ## ## ## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ## ############################################################################## -## singlelist.h +## circlesinglelist.h */ -#ifndef LINKEDLIST_H -#define LINKEDLIST_H +#ifndef CIRCLESINGLELIST_H +#define CIRCLESINGLELIST_H #include -class SingleList{ +class CircleSingleList{ public: - SingleList() : head(NULL) {}; - SingleList(const SingleList& rhs); - SingleList operator=(SingleList rhs); - ~SingleList(); + 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); @@ -39,15 +34,15 @@ class SingleList{ int data; Node *next; Node(): data(), next(NULL) {}; - Node(int val): data(val), next(NULL) {}; + Node(int val): data(val), next(this) {}; }; - Node *head; - bool insert(int val, Node *&head); - bool insert(int val, int key, Node *&head); - bool remove(int val, Node *&head); - bool replace(int val, int key, Node *&head); + 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, Node *start) const; + Node* findPrevious(int val) const; void print(Node *start) const; }; diff --git a/plates/circlesinglelist/driver.cpp b/plates/circlesinglelist/driver.cpp index be746e1..31408db 100644 --- a/plates/circlesinglelist/driver.cpp +++ b/plates/circlesinglelist/driver.cpp @@ -1,14 +1,14 @@ /*############################################################################# ## Author: Shaun Reed ## ## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ## -## About: A driver program to test a singly linked list ## +## About: A driver program to test a circular singly linked list ## ## ## ## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ## ############################################################################## ## driver.cpp */ -#include "singlelist.h" +#include "circlesinglelist.h" #include enum OPS { @@ -19,14 +19,14 @@ int main() { std::cout << "Driver: \n"; - SingleList testList; + CircleSingleList testList; bool exit = false; int choice = -1; int val, key; while (!exit) { - std::cout << "##### Singly Linked List Menu #####\n\t0. 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; @@ -51,7 +51,7 @@ int main() std::cin >> key; std::cin.clear(); if (testList.insert(val, key)) { - std::cout << "List after inserting [" + std::cout << "List after inserting [" << val << "] at [" << key << "]: \n"; testList.print(); } @@ -91,7 +91,7 @@ int main() std::cin >> key; std::cin.clear(); if (testList.replace(val, key)) { - std::cout << "List after replacing [" + std::cout << "List after replacing [" << key << "] by [" << val << "]: \n"; testList.print(); }