C++ SLNode::contents方法代码示例

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);
  }