bool SList::removeFirst(int contents) { SLNode* toRemove = NULL; SLNode* nodeMark = head; SLNode* lagMark = NULL; for (unsigned int i = 0; i < size; i++){ if (nodeMark->getContents() != contents && nodeMark->getNextNode() != NULL){ lagMark = nodeMark; nodeMark = nodeMark->getNextNode(); } else if (nodeMark->getContents() == contents){ toRemove = nodeMark; } } if (toRemove == NULL) { return false; } if (lagMark == NULL){ removeHead(); } else if (toRemove->getNextNode() == NULL) { removeTail(); } else { size--; nodeMark = nodeMark->getNextNode(); lagMark->setNextNode(nodeMark); delete toRemove; } toRemove = NULL; nodeMark = NULL; lagMark = NULL; return true; }
bool SList::removeFirst (int target) { if (head == NULL) return false; else { SLNode* trailer = NULL; SLNode* leader = head; while (leader != NULL && leader->getContents() != target) { trailer = leader; leader = leader->getNextNode(); } if (leader == NULL) { return false; } else if (leader == head) { removeHead(); return true; } else { trailer->setNextNode(leader->getNextNode()); delete leader; --numNodes; return true; } } }
//Prints the contents of the list in the format: NUM1,NUM2,...,LASTNUM //Empty string on empty list std::string SList::toString() const{ std::string listContents = ""; SLNode *p = head; std::stringstream ss; unsigned int count; if(p == NULL){ return ""; } count = 0; while(p != NULL){ if(count == 0){ ss << p->getContents(); //listContents += (std::to_string(p->getContents())); p = p->getNextNode(); count++; }else{ ss << ',' << p->getContents(); //listContents += (',' + std::to_string(p->getContents())); p = p->getNextNode(); } } listContents = ss.str(); return listContents; }
string SList::toString () const{ stringstream ss; for(SLNode* i = head; i != NULL; i = i->getNextNode()){ ss << i->getContents(); if(i->getNextNode() != NULL) ss << ","; } return ss.str(); }
string SList::toString () const { //Need to include sstream for this. stringstream ss; //Fetch the contents. for (SLNode* i = head; i != NULL; i=i->getNextNode()) { ss << i->getContents(); if(i->getNextNode() != NULL) ss << ','; } return ss.str(); }
void SList::insertTail (int contents) { if(head == NULL){ insertHead(contents); } else { SLNode* i = head; while (i->getNextNode() !=NULL) { i=i->getNextNode(); } SLNode* node = new SLNode(contents); i->setNextNode(node); size++; } }
void SList::insertTail (int newTail) { SLNode* temp = new SLNode(newTail); if (head == NULL) { insertHead(newTail); } else { SLNode* i = head; while (i->getNextNode() != NULL) { i = i->getNextNode(); } i->setNextNode(temp); size++; } }
void SList::insertTail (int contents) { if (head == NULL) { insertHead(contents); } else { SLNode* i = head; SLNode* newNode = new SLNode(contents); while (i->getNextNode() != NULL) { i = i->getNextNode(); } i->setNextNode(newNode); ++numNodes; } }
void SList::insertTail (int contents) { SLNode* temp = new SLNode(contents); temp->setNextNode(NULL); if (head == NULL) { head = temp; } else { SLNode* tail = head; while (tail->getNextNode() != NULL) { tail = tail->getNextNode(); } tail->setNextNode(temp); } size++; }
void SList::insertTail(int value) { if(head == NULL) { insertHead(value); } else { SLNode* newNode = new SLNode(value); SLNode* temp = head; while(temp->getNextNode() != NULL) { temp = temp->getNextNode(); } temp->setNextNode(newNode); size++; } }// create a new SLNode and attach at the end of list
void SList::removeTail () { if(head == NULL){ } else if (head->getNextNode()==NULL) { removeHead(); } else { SLNode* i = head; SLNode* j=NULL; while (i->getNextNode() !=NULL) { j=i; i=i->getNextNode(); } delete i; j->setNextNode(NULL); size--; } }
void SList::removeTail () { if (head != NULL) { if (head->getNextNode() == NULL) { delete head; head = NULL; } else { SLNode* nextToTail = head; SLNode* tail = head->getNextNode(); while (tail->getNextNode() != NULL) { nextToTail = tail; tail = tail->getNextNode(); } delete tail; nextToTail->setNextNode(NULL); } size--; } }
void SList::insertTail (int contents){ if(head != NULL) { //Finds the tail. SLNode* i = head; while (i->getNextNode() != NULL) { //Starts at head and moves it over to the last node. i = i->getNextNode(); } SLNode* node = new SLNode(contents); //points at the end and inserts the new node that was just created. i->setNextNode(node); size++; } else { //Empty list - make it to insert head as it's the same thing. insertHead(contents); } }
string SList::toString() const { string listContents; stringstream ss; if (head != NULL){ ss << head->getContents(); if (head->getNextNode() != NULL){ SLNode* currentNode = head->getNextNode(); for (unsigned int i = 1; i < size; i++){ ss << ","; ss << currentNode->getContents(); if (currentNode->getNextNode() != NULL){ currentNode = currentNode->getNextNode(); } } } } ss >> listContents; return listContents; }
void SList::removeTail () { if (head != NULL) { SLNode* i = head; SLNode* trailer = NULL; while (i->getNextNode() != NULL) { trailer = i; i = i->getNextNode(); } delete i; --numNodes; if (trailer == NULL) { head = NULL; } else { trailer->setNextNode(NULL); } } }
string SList::toString() { stringstream list; SLNode* temp = head; if(head == NULL) { return list.str(); } else { while(temp->getNextNode() != NULL) { list << temp->getContents() << ","; temp = temp->getNextNode(); } list << temp->getContents(); } return list.str(); }
void SList::insert(int contents) { if (head == NULL) { insertHead(contents); } else { size++; SLNode* newNode = new SLNode(contents); if (head->getContents() > contents){ SLNode* oldHead = head; head = newNode; head->setNextNode(oldHead); oldHead = NULL; } else { if (head->getNextNode() == NULL) { head->setNextNode(newNode); } else { SLNode* nodeMark = head->getNextNode(); SLNode* lagMark = NULL; for (unsigned int i = 0; i < size; i++) { if (nodeMark->getContents() < contents && nodeMark->getNextNode() != NULL) { lagMark = nodeMark; nodeMark = nodeMark->getNextNode(); } } if (lagMark == NULL) { head->setNextNode(newNode); newNode->setNextNode(nodeMark); } else if (nodeMark->getNextNode() == NULL) { nodeMark->setNextNode(newNode); } else { lagMark->setNextNode(newNode); newNode->setNextNode(nodeMark); } nodeMark = NULL; lagMark = NULL; } } newNode = NULL; } }
void SList::removeTail (){ if (head == NULL) { //DO NOTHING } else if (head->getNextNode() == NULL) { removeHead(); } else { SLNode* i = head; SLNode* j = NULL; while (i->getNextNode() != NULL) { //j is i and then i moves over one. j tails the node before i. j = i; //Starts at head and moves it over to the last node. i = i->getNextNode(); } //i is the tail. delete i; //need j to tail it and null out the last node. j->setNextNode(NULL); size--; } }
void SList::removeTail() { SLNode* currentNode = mHead; if(currentNode != 0) { SLNode* nextNode = currentNode->getNextNode(); if(nextNode == 0) { delete mHead; mHead = 0; mSize = 0; } else { SLNode* secondNode = nextNode->getNextNode(); while(secondNode != 0) { currentNode = nextNode; nextNode = secondNode; secondNode = secondNode->getNextNode(); } delete nextNode; currentNode->setNextNode(0); --mSize; } } }
void SList::removeTail() { if(head != NULL) { SLNode* lastNode = head; SLNode* nodeToDelete = head; if(lastNode->getNextNode() == NULL) { removeHead(); } else { while(lastNode->getNextNode()->getNextNode() != NULL) { lastNode = lastNode -> getNextNode(); } nodeToDelete = lastNode->getNextNode(); lastNode-> setNextNode(NULL); delete nodeToDelete; size--; } } }
void SList::insert (int newContents) { if (head == NULL) { insertHead (newContents); } else if (head->getNextNode() == NULL) { if (newContents < head->getContents()) { insertHead(newContents); } else { insertTail(newContents); } } else { SLNode* trailer = NULL; SLNode* leader = head; while (leader->getNextNode() != NULL && newContents > leader->getContents()) { trailer = leader; leader = leader->getNextNode(); } if (leader->getNextNode() == NULL && newContents > leader->getContents()) { insertTail(newContents); } else { SLNode* theNode = new SLNode (newContents); theNode->setNextNode(leader); if (trailer == NULL) { head = theNode; numNodes++; } else { trailer->setNextNode(theNode); numNodes++; } } } }
string SList::toString() const { stringstream ss; if (head == NULL) { ss.str(""); } else { int i = 1; for (SLNode* n = head; n != NULL; n = n->getNextNode()) { ss << n->getContents(); if (i < size) ss << ","; i++; } } return ss.str(); }
void SList::removeTail() { if(head != NULL) { SLNode* i = head; SLNode* trailer = NULL; while(i->getNextNode() != NULL) { trailer = i; i = i->getNextNode(); } delete i; size--; if(trailer == NULL) { head = NULL; } else { trailer->setNextNode(NULL); } } }//remove the tail node from the list
string SList::toString () const { stringstream listStream; SLNode* current; current = head; if (head == NULL){ cout << "" << endl; } else { while (current != NULL) { listStream << current->getContents() << ","; current = current->getNextNode(); } } return(listStream.str().substr(0,listStream.str().length() - 1)); }
SLNode* SList::getTail() const { SLNode* currentNode = mHead; if(currentNode != 0) { while(true) { SLNode* const nextNode = currentNode->getNextNode(); if(nextNode == 0) { return currentNode; } currentNode = nextNode; } } return currentNode; }
void SList::insertTail (int newContents) { SLNode* newNode = new SLNode(newContents); SLNode* temp = head; if(head == NULL) { head = newNode; } else { while(temp->getNextNode() != NULL) { temp = temp -> getNextNode(); } temp -> setNextNode(newNode); } size++; }
void SList::insertTail(int nodeContents) { if (head == NULL) { insertHead(nodeContents); } else { SLNode* newTail = new SLNode(nodeContents); if (head->getNextNode() == NULL) { head->setNextNode(newTail); } else { SLNode* oldTail = head->getNextNode(); for (unsigned int i = 1; i < size; i++){ if (oldTail-> getNextNode() != NULL){ oldTail = oldTail->getNextNode(); } } oldTail->setNextNode(newTail); oldTail = NULL; } newTail = NULL; size++; } }