C++ ListNode::getNext方法代码示例

bool LinkedList::removeFromBack(string &output)
{
    if (!isEmpty())
    {

        ListNode* currNode = head;
        ListNode* prevNode;


        // move to second last node
        while (currNode->getNext() != NULL)
        {
            prevNode = currNode;
            currNode = currNode->getNext();
        }
            

        output = currNode->value;
        delete currNode;
        prevNode->next = NULL;
        last = prevNode;
    }
    else
    {
        return false;
    }
        
}

bool List::remove(Object* const object)
{
	bool objectFound = false;

	ListNode* temp = this->first; 
	ListNode* prev = NULL;
	ListNode* next = NULL;

	while( temp != NULL ) {
		if (object == temp->getObject()) {
			next = temp->getNext();
			delete temp;
			if(next == NULL)
				last = NULL;
			if(prev == NULL)
				first = next;
			else
				prev->setNext(next);
			objectFound = true;
			break;
		}
		prev = temp;
		temp = temp->getNext();
	}
	return objectFound;
}

void LinkedList::printList(ofstream& out){
   out << "ListHead --> (" << listHead->getData() << ", " << listHead->getNext() << ") ";
   ListNode* temp = listHead->getNext();
   while(temp != NULL){
      out << "--> (" << temp->getData() << ", " << temp->getNext() << ") ";
      temp = temp->getNext();
   }
   out << endl;
}

ListNode* LinkedList::findSpot(int input){
   if(isEmpty()){
      return listHead;
   }
   ListNode* temp = listHead;
   while(temp->getNext() != NULL && temp->getNext()->getData() < input){
      temp = temp->getNext();
   }
   return temp;
}

ListIterator<Object> List<Object>::findPrevious( const Object& data ) const {
	ListNode<Object>* node = head;
	while( node->getNext() != NULL && node->getNext()->getElement() != data ) {
		node = node->getNext();
	}
	if (node->getNext() == NULL) {
		node = NULL;
	}
	return ListIterator<Object>( node );
}

// Show the contents of the list
void LinkedList::print(void)
{
  ListNode *node = head.getNext();

  while (node != 0) {
    cout << setw(6) << node->getVal();
    node = node->getNext();
  }
  cout << endl;
}

void List<Object>::remove( const Object& data ) {
	ListIterator<Object> iter = findPrevious( data );
	if (iter.isValid()) {
		ListNode<Object>* node = findPrevious( data ).current;
		if (node->getNext() != NULL) {
			ListNode<Object> *oldNode = node->getNext();
			node->setNext( node->getNext()->getNext() );  // Skip oldNode
			delete oldNode;
		}
	}
}

// Insert in sorted order (ascending)
ListNode * LinkedList::insert(const int val)
{
  ListNode *node = head.getNext();
  ListNode *prev = &head;

  while (node != 0 && node->getVal() < val) {
    prev = node;
    node = node->getNext();
  }
  return prev->setNext(new ListNode(val, prev->getNext()));
}

void LinkedList::listInsert(int input, ofstream& out){
   ListNode* spot = findSpot(input);
   if(spot->getNext() != NULL){
      if(spot->getNext()->getData() == input){
         out << input << " is already in the list." << endl;
         return;
      }
   }
   ListNode* temp = new ListNode(input, spot->next);
   spot->next = temp;
   printList(out);
}

void List::Print() const {
	if(head==NULL)
		cout << "The list is empty." << endl << endl;
	else{
		cout << "The current list is as follows:" << endl << endl;
		ListNode * index = head;
		cout << index->getMyInt() << endl;
		while(index->getNext()!=NULL){
			index=index->getNext();
			cout << index->getMyInt() << endl;
		}
		cout << endl << endl;
	}
}

Item List::get(int n){
	
	if(n <= 0) return Item("Integer invalid");
	
	ListNode *k = head->getNext();
	
	if(k == NULL) return Item("Not enough items"); //No items
	if(n == 1) return Item(head->getItem()); //First item on the list
	
	for(int i = 2; i < n ; i++){
		k = k->getNext();
		if(k == NULL) return Item("Not enough items");
	}
	return Item(k->getItem()); //Returns the item of n on the list
}

bool List::member(ICollectible *c) const{
    for(ListNode *current = head; current != NULL; current = current->getNext())
        if(current->getElem() == c)
            return true;
    return false;
        
}

// Remove the first node having the specified value (if present)
int LinkedList::remove(const int val)
{
  ListNode *node = head.getNext();
  ListNode *prev = &head;

  while (node != 0 && node->getVal() != val) {
    prev = node;
    node = node->getNext();
  }
  if (node->getVal() == val) {
    prev->setNext(node->getNext());
    delete node;
    return val;
  }
  return -1;
}

int List::length(){
	int counter = 0;
	if(empty()) return 0;
	ListNode *n = head->getNext();
	if(n == NULL){
		return 1;
	} 
	else{
		counter++; //list had at least 1 item
		while (n != NULL){ // while list is not empty
			counter++;
			n = n->getNext();
		}
		return counter; //Returns the # of items in the list
	}
}

  vector< Point2d > PointPersistentList::enumerateNE(coord_t x, coord_t y) {
    vector< Point2d > v;
    // determine the time at which to search by searching for the x
    int index = binarySearchX(x);
    // if set of points is empty, bail out
    if(index == -1) return v;
    // while the closest point is too small
    while(points_sorted_by_x[index].x < x) {
      // check the previous point, which should be larger since the
      // array is sorted by x descending
      --index;
      // if we have passed the beginning of the array, then there are no
      // points within the query region
      if(index < 0)
	return v;
    }
    // get the first node in this list at time index
    ListNode<Point2d, Point2d::yxdesc >* pln = points_right.getList(index);
    // while the current point is not null and has a greater or equal
    // y than the query
    while(pln != NULL && pln->data.y >= y) {
      // push the point onto the list to be returned
      v.push_back(pln->data);
      // move on to next point
      pln = pln->getNext(index);
    }
    return v;
  }