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::RemoveTail()
{
//removes the tail node from the list, or does nothing if the list is empty
SLNode *tmp = head_;
if(tmp != NULL)
{
// list is not empty
if (head_ == tail_)
{
// list only has 1 item in it, clear the list
delete head_;
head_ = NULL;
tail_ = NULL;
size_ = 0;
return;
}
while(tmp->next_node() != tail_)
{
// find the item just before the tail
tmp = tmp->next_node();
}
// delete the old tail
delete tail_;
// this will be the new end of the list
tmp->set_next_node(NULL);
tail_ = tmp;
size_--;
return;
}
}
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_++;
}
}
void SLList::Insert(int contents)
{
//Checks if head is null or contents is < head_->contents();
if (head_ == NULL || head_->contents() > contents)
{
InsertHead(contents);
} else if ( tail_->contents() < contents)
{
// cout << " got it: " << contents << endl;
// cout << ToString();
InsertTail(contents);
} else
{
//creates iterator and newnode
SLNode* iterator;
iterator = head_;
while (iterator->next_node() != NULL && contents > iterator->next_node()->contents())
{
iterator = iterator->next_node();
}
if (iterator != tail_)
{
SLNode *newNode = new SLNode(contents);
newNode->set_next_node(iterator->next_node());
iterator->set_next_node(newNode);
size_ +=1;
} else
{
InsertTail(contents);
}
}
}
/*
* 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
}
void SLList::InsertTail(int newTail) {
if(head_ == NULL) {
InsertHead(newTail);
}
else {
SLNode* i = head_;
while (i->next_node() != NULL) {
i = i->next_node();
}
SLNode* node = new SLNode(newTail);
i->set_next_node(node);
size_++;
}
}
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_++;
}
}
/**
* 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();
}
void SLList::RemoveTail() {
if(head_ == NULL) {
//DO NOTHING
}
else if (head_->next_node() == NULL) {
RemoveHead();
}
else {
SLNode* i = head_;
SLNode* j = NULL;
while (i->next_node() != NULL) {
j = i;
i = i->next_node();
}
delete i;
j->set_next_node(NULL);
size_--;
}
}
void SLList::RemoveTail()
{
if(head_ && size_ >= 2) //we need to know that there is a list bigger that 1 before we remove tail
{
SLNode* remove_tail = tail_;
SLNode* current = head_; //new pointer assigned to head
while(current->next_node() != tail_)//traverses list while not at tail position
{
current = current->next_node();
}
tail_ = current;
tail_->set_next_node(NULL);
delete remove_tail;
size_--;
}
else if(size_ == 1) //checks if the size is one
{
head_ = NULL; //assigns head to null
size_ = 0; //set size to 0
}
}
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;
}
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();
}
/**
* removes the tail node from the list,
* or does nothing if the list is empty
*/
void SLList::RemoveTail()
{
if (head_ != NULL)
{
if (head_ == tail_)
{
RemoveHead();
} else
{
SLNode* temp = head_;
while (temp->next_node() != tail_)
temp = temp->next_node();
temp->set_next_node(NULL);
delete tail_;
tail_ = temp;
size_ -= 1;
}
}
}
bool SLList::RemoveFirstOccurence(int contents)
{
//returns false for empty list
if (head_ == NULL)
{
return false;
// uses RemoveTail() if tail == contents
} else if (tail_->contents() == contents)
{
RemoveTail();
return true;
} else
{
//creating pointers
SLNode* iterator = head_, *temp = head_->next_node();
//traverses to find match for contents
while (contents != temp->contents() && temp->next_node() != NULL)
{
temp = temp->next_node();
iterator = iterator->next_node();
}
//returns false if contents are not in list
if (temp == tail_ && temp->contents() != contents)
{
return false;
} else
//checks if temp is the node to delete then executes
if(temp->contents() == contents)
{
iterator->set_next_node(temp->next_node());
delete temp;
size_ = size_ - 1;
temp = NULL;
return true;
}
}
}
void SLList::RemoveHead()
{
if (head_ != NULL)
{
SLNode* temp; //create temporary node
temp = head_; //point temp at head
head_ = temp->next_node(); //
delete temp; //delete contents of temp(formerly head)
temp = NULL; //assign NULL to temp
size_--; //decrement size
if (size_ == 0)
{
tail_ = NULL;
}
}
// (*MODIFY*)
// removes the head node from the list,
// or does nothing if the list is empty
// (*NEW*) - Handle tail_ when the last remaining node in the list is removed
}
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;
}
}
