shaunrd0
/
klips
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/shaunrd0/klips

This commit is contained in:
Shaun Reed 2020-04-15 23:06:26 +00:00
parent 650731a5ba fb0251c2b6
commit 20071c135c
9 changed files with 431 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1,2 +1,4 @@
build/
**/.vscode
**/driver
**/*.o

10
plates/linkedlists/Makefile
View File

@ -5,15 +5,15 @@ CXXFLAGS=-g -Wall
# Driver
###############################################################################
driver: driver.cpp linkedlist.o
${CXX} ${CXXFLAGS} driver.cpp linkedlist.o -o driver
driver: driver.cpp singlelist.o
${CXX} ${CXXFLAGS} driver.cpp singlelist.o -o driver
###############################################################################
# LinkedList
# SingleList
###############################################################################
linkedlist.o: linkedlist.cpp linkedlist.h
${CXX} ${CXXFLAGS} -c linkedlist.cpp -o linkedlist.o
singlelist.o: singlelist.cpp singlelist.h
${CXX} ${CXXFLAGS} -c singlelist.cpp -o singlelist.o
###############################################################################
# Clean

BIN
plates/linkedlists/driver
View File

Binary file not shown.

60
plates/linkedlists/driver.cpp
View File

@ -1,8 +1,18 @@
#include "linkedlist.h"
/*#############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ##
## About: A driver program to test a singly linked list ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
##############################################################################
## driver.cpp
*/
#include "singlelist.h"
#include <iostream>
enum OPS {
EXIT, INSERT, INSERTAT, EMPTY, PEEK, PRINT, FIND
EXIT, INSERT, INSERTAT, EMPTY, PEEK, PRINT, FIND, REMOVE, REPLACE
};
int main()
@ -12,12 +22,12 @@ int main()
SingleList testList;
bool exit = false;
int choice = -1;
int val, ins;
int val, key;
while (!exit)
{
std::cout << "##### 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";
<< "\n\t5. Print list\n\t6. Find\n\t7. Remove\n\t8. Replace\n";
std::cin >> choice;
std::cin.clear();
switch (choice)
@ -34,18 +44,15 @@ int main()
break;
case INSERTAT:
std::cout << "Enter a value to insert at within our list: ";
std::cin >> ins;
std::cin.clear();
std::cout << "Enter a value to add to our list: ";
std::cout << "Enter a new value to add to our list: ";
std::cin >> val;
std::cin.clear();
if (!testList.insert(val, ins)) {
std::cout << "No changes made, [" << ins << "] was not found in our list\n";
}
else {
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 [" << ins << "]: \n";
<< val << "] at [" << key << "]: \n";
testList.print();
}
break;
@ -55,20 +62,43 @@ int main()
break;
case PEEK:
std::cout << "[" << testList.peek() << "] is at the top of our list\n";
testList.peek();
break;
case PRINT:
testList.print();
// test2.print();
// test3.print();
break;
case FIND:
std::cout << "Enter a value to search for within our list: ";
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;

199
plates/linkedlists/linkedlist.cpp
View File

@ -1,199 +0,0 @@
#include "linkedlist.h"
/******************************************************************************
* Constructors, Destructors, Operators
*****************************************************************************/
/**
* @brief Construct a new SingleList::SingleList object from an existing one
*
* @param rhs SingleList object
*/
SingleList::SingleList(const SingleList& rhs)
{
}
/**
* @brief Copy the rhs SingleList::SingleList into the lhs of an assignemnt
*
* @param rhs SingleList object
* @return SingleList& The copied rhs SingleList to the lhs of the assignment
*/
SingleList& SingleList::operator=(const SingleList& rhs)
{
return *this;
}
/**
* @brief Destroy the SingleList::SingleList object
*/
SingleList::~SingleList()
{
}
/******************************************************************************
* 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)
{
Node *newNode = new Node(val);
if (isEmpty())
head = newNode;
else {
newNode->next = head;
head = newNode;
}
return true;
}
/** 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)
{
Node *newNode = new Node(val);
if (isEmpty() || head->data == key) return insert(val);
Node *result = findPrevious(key, head);
if (result == NULL) return false;
else {
newNode->next = result->next;
result->next = newNode;
return true;
}
}
/** makeEmpty
* @brief Empty this SingleList object, deleting all associated Nodes
*/
void SingleList::makeEmpty()
{
Node *temp;
while(head != NULL) {
temp = head;
head = head->next;
delete temp;
}
}
/** isEmpty
* @brief Determine if the SingleList is empty
*
* @return true If the SingleList::head is NULL
* @return false If the SingleList::head contains data
*/
bool SingleList::isEmpty() const
{
return head == NULL;
}
/** peek
* @brief returns the value at the SingleList::head
*
* @return int The value held at the Node pointed to by SingleList::head
*/
int SingleList::peek() const
{
if (head == NULL) return -1;
else return head->data;
}
/** print
* @brief Output the data held by the SingleList object
* Calls to the private print()
*/
void SingleList::print() const
{
print(head);
}
/** 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
*/
bool SingleList::find(int val) const
{
Node *result = find(val, head);
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
*****************************************************************************/
/** 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
*/
SingleList::Node* SingleList::find(int val, Node *start) const
{
if (start == NULL || start->data == val) return start;
Node *temp = start;
while (temp->next != NULL) {
temp = temp->next;
if (temp->data == val) break;
}
if (temp->data == val) return temp;
else return NULL;
}
/** 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
*/
SingleList::Node* SingleList::findPrevious(int val, Node *start) const
{
if (isEmpty()) return NULL;
else if (start->data == val) return start;
Node *temp = start;
while (temp->next != NULL) {
if (temp->next->data == val) return temp;
temp = temp->next;
}
return NULL;
}
/** print
* @brief Output the contents of a SingleList from the given Node to NULL
*
* @param start The Node to begin traversing output from
*/
void SingleList::print(Node *start) const
{
Node *temp = start;
std::cout << "List Contents: ";
while (temp != NULL) {
std::cout << temp->data << " | ";
temp = temp->next;
}
std::cout << std::endl;
}

34
plates/linkedlists/linkedlist.h
View File

@ -1,34 +0,0 @@
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include <iostream>
// Singly Linked List
class SingleList{
public:
SingleList() : head(NULL) {};
SingleList(const SingleList& rhs);
SingleList& operator=(const SingleList& rhs);
~SingleList();
bool insert(int val);
bool insert(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(00), next(NULL) {};
Node(int val): data(val), next(NULL) {};
};
Node *head;
Node* find(int val, Node *start) const;
Node* findPrevious(int val, Node *start) const;
void print(Node *start) const;
};
#endif

BIN
plates/linkedlists/linkedlist.o
View File

Binary file not shown.

325
plates/linkedlists/singlelist.cpp Normal file
View File

@ -0,0 +1,325 @@
/*#############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2020 Shaun Reed, all rights reserved ##
## About: An example of a singly linked list ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
##############################################################################
## singlelist.cpp
*/
#include "singlelist.h"
/******************************************************************************
* Constructors, Destructors, Operators
*****************************************************************************/
/**
* @brief Construct a new SingleList::SingleList object from an existing one
*
* @param rhs SingleList object
*/
SingleList::SingleList(const SingleList& rhs)
{
head = rhs.head;
}
/**
* @brief Copy the rhs SingleList::SingleList into the lhs of an assignemnt
*
* @param rhs SingleList object
* @return SingleList& The copied rhs SingleList to the lhs of the assignment
*/
SingleList& SingleList::operator=(const SingleList& rhs)
{
makeEmpty();
head = rhs.head;
return *this;
}
/**
* @brief Destroy the SingleList::SingleList object
*/
SingleList::~SingleList()
{
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 inserted = insert(val, head);
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 SingleList::insert(int val, int key)
{
bool inserted = insert(val, key, head);
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 removed = remove(val, head);
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 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";
return replaced;
}
/** makeEmpty
* @brief Empty this SingleList object, deleting all associated Nodes
*/
void SingleList::makeEmpty()
{
Node *temp;
while(!isEmpty()) {
temp = head;
head = head->next;
delete temp;
}
}
/** isEmpty
* @brief Determine if the SingleList is empty
*
* @return true If the SingleList::head is NULL
* @return false If the SingleList::head contains data
*/
bool SingleList::isEmpty() const
{
return head == NULL;
}
/** peek
* @brief returns the value at the SingleList::head
*
* @return int The value held at the Node pointed to by SingleList::head
*/
void SingleList::peek() const
{
if (!isEmpty())
std::cout << "[" << head->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
* Calls to the private print()
*/
void SingleList::print() const
{
if(!isEmpty()) print(head);
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
*/
bool SingleList::find(int val) const
{
Node *result = find(val, head);
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
* @return true If the value was inserted
* @return false If the value could not be inserted
*/
bool SingleList::insert(int val, Node *&head)
{
Node *newNode = new Node(val);
// If the list is not empty, update next pointer to head node
if (!isEmpty()) newNode->next = head;
// Always set head to our newNode
head = 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
* @return true If the value was inserted
* @return false If the value was not inserted
*/
bool SingleList::insert(int val, int key, Node *&head)
{
Node *newNode = new Node(val);
if (isEmpty()) return false;
// Let insert() handle inserting at the head
else if (head->data == key) return insert(val);
Node *keyNode = findPrevious(key, head);
// 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
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 head Head 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)
{
if (head == NULL) return false;
else if (head->data == val) {
head = head->next;
return true;
}
Node *prevNode = findPrevious(val, head);
if (prevNode == NULL) return false;
Node *gtfo = prevNode->next;
prevNode->next = prevNode->next->next;
delete gtfo;
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
* @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)
{
Node *replacee = find(key, head);
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 SingleList
* @return SingleList::Node* A pointer to the Node containing the search value
*/
SingleList::Node* SingleList::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;
if (foundNode->data == val) return foundNode;
}
// 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 SingleList
* @return SingleList::Node* A pointer to the Node previous to the given value
*/
SingleList::Node* SingleList::findPrevious(int val, Node *start) const
{
if (isEmpty()) return NULL;
else if (start->data == val) return start;
Node *temp = start;
while (temp->next != NULL) {
if (temp->next->data == val) return temp;
temp = temp->next;
}
return NULL;
}
/** print
* @brief Output the contents of a SingleList from the given Node to NULL
*
* @param start The Node to begin traversing output from
*/
void SingleList::print(Node *start) const
{
Node *temp = start;
std::cout << "List Contents: ";
while (temp != NULL) {
std::cout << temp->data << " | ";
temp = temp->next;
}
std::cout << std::endl;
}

54
plates/linkedlists/singlelist.h Normal file
View File

@ -0,0 +1,54 @@
/*#############################################################################
## 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 ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
##############################################################################
## singlelist.cpp
*/
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include <iostream>
class SingleList{
public:
SingleList() : head(NULL) {};
SingleList(const SingleList& rhs);
SingleList& operator=(const SingleList& rhs);
~SingleList();
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;
void peek() const;
void print() const;
bool find(int val) const;
private:
struct Node {
int data;
Node *next;
Node(): data(00), next(NULL) {};
Node(int val): data(val), next(NULL) {};
};
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* find(int val, Node *start) const;
Node* findPrevious(int val, Node *start) const;
void print(Node *start) const;
};
#endif