void PtrListRep::remove(void* element) { if(element!=NULL && _first!=NULL) { for(ListNode* n=_first; n!=NULL; n=n->getNext()) { void* el = n->getElement(); if(el==element) { // remove the node ListNode* prev = n->getPrevious(); ListNode* next = n->getNext(); if(prev!=NULL) prev->setNext(next); else // the node is the very first _first = next; if(next!=NULL) next->setPrevious(prev); else // the node is the last _last = prev; delete n; break; } } } }
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 KdTree::add( KdTreeNode* kdnode, Object* ob ) { //std::cout<<_buffer_l<<std::endl; ListNode* node = &_ListNodeBuffer[_buffer_l++]; node->setObject( ob ); node->setNext( kdnode->getList() ); kdnode->setList( node ); }
// Add to the end of the list ListNode * LinkedList::append(const int val) { ListNode *node = &head; while (node->hasNext()) { node = node->getNext(); } return node->setNext(new ListNode(val)); }
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 PtrListRep::add(void* element) { ListNode* n = new ListNode(element); if(_last==NULL) { // this is the very first one _first = _last = n; } else { // append to the end _last->setNext(n); n->setPrevious(_last); _last = n; } }
void List::push_back(const char * a){ Item b(a); ListNode *node = new ListNode(b); if (head == NULL) { // list is empty head = node; tail = node; } else { tail->setNext(node); tail = node; } }
void List::append(Item a) { ListNode *node = new ListNode(a); if (head == NULL) { // list is empty head = node; tail = node; } else { tail->setNext(node); tail = node; } }
void List::Insert(int newInt){ if(head==NULL){ ListNode * h = new ListNode(newInt,NULL); head=h; } else{ ListNode * index = head; ListNode * prev = NULL; ListNode * newListNode = new ListNode(newInt); while(index->getNext()!=NULL && index->getMyInt()<=newInt){ prev=index; index=index->getNext(); } if(index->getMyInt()>newInt){ newListNode->setNext(index); if(prev!=NULL) prev->setNext(newListNode); else head=newListNode; } else index->setNext(newListNode); } }
// 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; }
void OrderedDictionary::makeListReverseOrder(OrderedDictionaryEntry *entry, ListNode *&head) { if(entry == NULL) return; // árbol vacío, no hay nada que hacer makeListReverseOrder(entry->getLesser(), head); // pone el elemento actual al final y crea la lista si estaba en NULL if(head == NULL){ head = new ListNode(entry->getVal()); } else { ListNode *entryNode = new ListNode(entry->getVal()); entryNode->setNext(head); head = entryNode; } makeListReverseOrder(entry->getGreater(), head); }
void List::remove(ICollectible *c) { ListNode *current = head; ListNode *previous = NULL; while(current != NULL && current->getElem() != c){ previous = current; current = current->getNext(); } if(current == NULL){ // final de la lista, no estaba return; } else if(current->getElem() == c){ // ya está, se borra --size; if(previous == NULL) // se borra el primer elemento head = current->getNext(); else previous->setNext(current->getNext()); delete current; } }
void List::add(ICollectible* c) { if(head == NULL){ // list vacía; tamaño = 1 head = new ListNode(c); size = 1; return; } ListNode *current = head; ListNode *previous; while(current != NULL && current->getElem() != c){ previous = current; current = current->getNext(); } if(current == NULL){ // final de la lista, se agrega previous->setNext(new ListNode(c)); ++size; } }
// Insert at the beginning of the list ListNode * LinkedList::prepend(const int val) { return head.setNext(new ListNode(val, head.getNext())); }