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

void findNSmallest2(T first, T last, size_t n, V oit) {
  std::auto_ptr<ListNode> head;
  std::vector<double> buffer(n, std::numeric_limits<double>::max());
  for (; first != last; ++first) {
    double tmp = *first;
    if (head.get() == NULL) {
      head.reset(new ListNode(tmp));
    }
    else {
      // Insertion into correct place
      ListNode* currNode = head.get();
      ListNode* prevNode = NULL;
      for (;;) {
        if (tmp < currNode->value()) {
          // Insert
          if (prevNode == NULL) {
            // Inserts at start
            head.release();
            head.reset(new ListNode(tmp, currNode));
          }
          else {
            // Insert part way through
            ListNode* newnode = new ListNode(tmp, currNode);
            prevNode->join(newnode);
          }
          break;
        }
        if (currNode->next() == NULL) {
          // Reached end of list
          ListNode* newnode = new ListNode(tmp);
          currNode->join(newnode);
          break;
        } else {
          prevNode = currNode;
          currNode = currNode->next();
        }
      }
    }
    // Trim list to size
    ListNode* currNode = head.get();
    for (size_t i = 0; currNode != NULL && i < n; ++i) {
      if (i == n - 1) {
        ListNode* tmp = currNode->next();
        currNode->join(NULL);
        delete tmp;
      }
      currNode = currNode->next();
    }
  }
  for (ListNode* currNode = head.get(); currNode != NULL;
      currNode = currNode->next()) {
    *oit = currNode->value();
  }
}

void PointerFIFO::put(void* val)
{
	ListNode *node = allocate();
	node->data(val);
	node->next(NULL);
	if (mTail!=NULL) mTail->next(node);
	mTail=node;
	if (mHead==NULL) mHead=node;
	mSize++;
}

void PointerFIFO::push_front(void* val)	// by pat
{
	// Pat added this routine for completeness, but never used or tested.
	// The first person to use this routine should remove this assert.
	ListNode *node = allocate();
	node->data(val);
	node->next(mHead);
	mHead = node;
	if (!mTail) mTail=node;
	mSize++;
}

  /* Return the +index+ numbered element from the beginning. */
  Object* List::locate(STATE, size_t index) {
    ListNode* cur = first_;

    while(index > 0) {
      if(cur->nil_p()) return Qnil;

      cur = cur->next();
      index--;
    }

    if(cur->nil_p()) return Qnil;
    return cur->object();
  }

  /* Search the List for +obj+ and remove all instances of it.
   *
   * Returns the number of elements removed. */
  size_t List::remove(STATE, const Object* obj) {
    if(empty_p()) return 0;

    size_t deleted = 0, counted = 0;

    ListNode* node = first_;
    ListNode* lst =  nil<ListNode>();
    ListNode* nxt =  nil<ListNode>();

    while(!node->nil_p()) {
      nxt = node->next();

      if(node->object() == obj) {
        deleted++;
        if(lst->nil_p()) {
          first(state, nxt);
        } else {
          lst->next(state, nxt);
        }

        if(last_ == node) {
          last(state, lst);
        }

        lst = nil<ListNode>();
      } else {
        counted++;
        lst = node;
      }

      node = nxt;
    }

    count(state, Integer::from(state, counted));

    return deleted;
  }