void SLList::Insert(int data)
{
SLNode* insert = new SLNode(data); //assigns data to new node
SLNode* current = head_; //assigns head to current
SLNode* prev = current;
if(!head_ || data <= current->contents()) //if there is a list or data is less than or equal to head_
{
InsertHead(data);
}
else if(data > tail_->contents()) //if data is greater than tail
{
InsertTail(data);
}
else
{
while(current->contents() < data) //while current is less than data
{
prev = current; //we assign prev to currents position
current = current->next_node(); //then assign current to next position
}
insert->set_next_node(current); //set node at currents position
prev->set_next_node(insert); //set data at proper position
size_++;
}
}
void SLList::Insert(int contents) {
if(head_ == NULL) {
InsertHead(contents);
}
else if(contents < GetHead()) {
InsertHead(contents);
}
else if (head_->next_node() == NULL && head_ != NULL) {
InsertTail(contents);
}
else if(contents > GetTail()) {
InsertTail(contents);
}
else {
SLNode* node = new SLNode(contents);
SLNode* i = head_;
SLNode* j = NULL;
while(i->contents() <= contents && i->next_node() != NULL) {
j = i;
i = i->next_node();
}
j->set_next_node(node);
node->set_next_node(i);
size_++;
}
}
void SLList::Insert(int contents)
{
if (contents < GetHead() || head_ == NULL)
{
InsertHead(contents);
}
else if (contents > GetTail())
{
InsertTail(contents);
}
else
{
SLNode *new_node = new SLNode(contents);
SLNode *it = head_;
SLNode *temp = it->next_node();
if (size_ == 2)
{
head_->set_next_node(new_node);
new_node->set_next_node(tail_);
}
else
{
while (temp->contents() < contents)
{
it = temp;
temp = temp->next_node();
}
it->set_next_node(new_node);
new_node->set_next_node(temp);
}
size_++;
}
}
/*
* returns a string representation of the contents
* of all nodes in the list, in the format
* NUM1, NUM2, ..., LASTNUM
* returns the empty string on an empty list (i.e. returns "")
*/
string SLList::ToString() const
{
std::stringstream ss;
ss.clear();
ss.str();
SLNode* temp = head_; //create temp to be an iterator
if(head_ != NULL)
{
while(temp->next_node() != NULL) //cycles through the list until null is next
{
ss << temp-> contents();
temp = temp->next_node();
ss << ", ";
}
ss << temp->contents(); //prints out the last node
}
else
{
ss << "";
}
string someString;
someString = ss.str();
return someString;
}
bool SLList::RemoveFirstOccurence(int data)
{
if(head_) //if there is a list
{
if(head_->contents() == data) //if the data is same as head
{
RemoveHead();
return true;
}
SLNode* prev = head_; //assign node to head_
SLNode* current = head_->next_node(); //assign current to node after head
while(current) //while current is not NULL
{
if(current->contents() == data) //if current = to data
{
prev->set_next_node(current->next_node()); //prev points to the node after current
if(current == tail_) //if current = tail, tail assigned to prev
{
tail_ = prev;
}
current = NULL; //dereference current
delete current; //delete current
size_--; //now we minus the size
return true;
}
prev = current; //these traverse prev before current
current = current->next_node();
}
}
else
{
return false;
}
}
string SLList::ToString() const {
stringstream ss;
for(SLNode* iterator = head_; iterator != NULL; iterator = iterator->next_node()) {
ss << iterator->contents();
if(iterator->next_node() != NULL) {
ss << ", ";
}
}
return ss.str();
}
int SLList::GetTail() {
if(head_ == NULL) {
return 0;
}
else {
SLNode* i = head_;
while(i->next_node() != NULL) {
i = i->next_node();
}
return i->contents();
}
}
string SLList::ToString() //uses string stream to display
{
stringstream stream;
for(SLNode* out = head_; out != NULL; out = out->next_node()) //sets out* to head, while not NULL points to next node
{
stream << out->contents(); //puts contents of each node into stream
if(out->next_node() != NULL) //if the next node is not NULL then is adds a comma for the incoming next node
{
stream << ", ";
}
}
return stream.str(); //returns contents of string
}
bool SLList::RemoveFirstOccurence(int contents) {
SLNode* node = new SLNode(contents);
if (contents == GetHead()) {
RemoveHead();
return true;
}
else if(contents == GetTail()) {
RemoveTail();
return true;
}
else if(head_ == NULL) {
return false;
}
else if (node == NULL) {
return false;
}
else if (contents != GetHead() && contents != GetTail()) {
SLNode* i = head_;
SLNode* j = NULL;
while (i->contents() != contents && i->next_node() != NULL) {
j = i;
i = i->next_node();
}
if(i->next_node() == NULL && i->contents() != contents) {
return false;
}
else {
SLNode* temp = i->next_node();
SLNode* temp2 = i;
delete temp2;
j->set_next_node(temp);
size_--;
return true;
}
}
else
return false;
}
/**
* returns a string representation of the contents
* of all nodes in the list, in the format
* NUM1, NUM2, ..., LASTNUM
* returns the empty string on an empty list (i.e. returns "")
*/
string SLList::ToString() const
{
if (head_ == NULL)
return "";
stringstream ss;
SLNode* temp = head_;
while (temp != NULL)
{
ss << temp->contents();
if (temp->next_node() != NULL)
ss << ", ";
temp = temp->next_node();
}
return ss.str();
}
string SLList::ToString() const
{
/* returns a string representation of the contents
of all nodes in the list, in the format
NUM1, NUM2, ..., LASTNUM
returns the empty string on an empty list (i.e. returns "")
*/
SLNode* current = head_;
std::stringstream ss;
if(current != NULL)
{
while (current != NULL)
{
ss << current->contents();
if(current->next_node() != NULL)
{
ss << ", ";
}
current = current->next_node();
}
}
return ss.str();
}
string SLList::ToString() const
{
SLNode *print = head_;
stringstream ss;
ss.str();
string list;
const char* separator = "";
if (head_ == NULL)
{
return "";
}
else if (head_ != NULL)
{
while (print != NULL)
{
ss << separator << print->contents();
print = print->next_node();
separator = ", ";
}
list = ss.str();
return list;
}
}
// For NULL
#include <cstddef>
#include <sstream>
#include "sl_list.h"
// To test for Header guards
#include "sl_list.h"
#include "sl_node.h"
#include "sl_node.h"
TEST_CASE("Default Constructor for SLNode") {
SLNode node, node2;
SLNode* p_node2 = &node2;
SECTION("Accessor for Contents") {
CHECK(node.contents() == 0);
}
SECTION("Accessor for Next Node") {
CHECK(node.next_node() == NULL);
}
SECTION("Mutator for Contents") {
node.set_contents(100);
CHECK(node.contents() == 100);
}
SECTION("Mutator for Next Node") {
node.set_next_node(&node2);
CHECK(node.next_node() == p_node2);
}
