C++ DLNode::setNext方法代码示例

void DLList::insert(int newValue) {
  if (head == NULL)
    pushFront(newValue);
  else if (newValue <= head->getContents())
    pushFront(newValue);
  else if (newValue >= tail->getContents())
    pushBack(newValue);
  else {
    DLNode* spot = head;

    while (spot->getNext() != NULL && newValue > spot->getContents())
      spot = spot->getNext();

    if (spot->getNext() == NULL && newValue >= spot->getContents())
      pushBack(newValue);
    else {
      DLNode* newNode = new DLNode(newValue);
      DLNode* trailer = spot->getPrevious();
      trailer->setNext(newNode);
      newNode->setNext(spot);
      newNode->setPrevious(trailer);
      spot->setPrevious(newNode);
      size++;
    }

  }
}

//create new DLNode with newContents and insert in ascending (based on newContents) order
void DLList::insert (int newContents)
{
    if(head == NULL || newContents < head->getContents())
    {
        pushFront(newContents);
        return;
    }
    
    DLNode* temp = head;
    
    while(temp->getNext() != NULL)
    {
        DLNode* nextTemp = temp->getNext();
        if(nextTemp->getContents() > newContents)
        {
            DLNode* inserted = new DLNode(newContents);
            
            inserted->setPrevious(temp);
            inserted->setNext(nextTemp);
            
            temp->setNext(inserted);
            nextTemp->setPrevious(inserted);
            
            size++;
            return;
        }
        temp = temp->getNext();
    }
    pushBack(newContents);
}

/**
 * Insert function that creates a new node and
 * inserts it in an appropriate location in the list.
 *@param string contents the contents of the new node.
 */
void DLList::insert(string contents)
{
    //Checks if head is null or contents is < head_->getContents();
    if (head_ == NULL)
    {
        pushFront(contents);
    } else if ( tail_->getContents() < contents)
    {
      //  cout << " got it: " << contents << endl;
     //   cout << ToString();
        pushBack(contents);
    } else 
    {
        //creates iterator and newnode
        DLNode* iterator;
        iterator = head_;
        while (iterator->getNext() != tail_ && contents > iterator->getNext()->getContents())
        {
        iterator = iterator->getNext();
        }
        if (iterator != tail_)
        {
            DLNode *newNode = new DLNode(contents);
            newNode->setNext(iterator->getNext());
            iterator->setNext(newNode);
            size_ +=1;
        } else
        {
            pushBack(contents);
        }
    }
}

void DLList::insert(int newContents) {
    if (head == NULL) {
        pushFront(newContents);
    } else {
        count++;
        DLNode* newNode = new DLNode(newContents);
        if (head->getContents() > newContents){
            DLNode* oldHead = head;
            head = newNode;
            head->setNext(oldHead);
            oldHead->setPrevious(head);
            oldHead = NULL;
        } else {
            if (head->getNext() == NULL) {
                head->setNext(newNode);
                newNode->setPrevious(head);
                tail = newNode;
            } else {
                DLNode* nodeMark = head->getNext();
                DLNode* lagMark = NULL;
                for (unsigned int i = 1; i < count; i++) {
                    if (nodeMark->getContents() < newContents && nodeMark->getNext() != NULL) {
                        lagMark = nodeMark;
                        nodeMark = nodeMark->getNext();
                    }
                }
                if ((lagMark == NULL) && (nodeMark->getNext() != NULL || nodeMark->getContents() > newContents)) {
                    head->setNext(newNode);
                    newNode->setNext(nodeMark);
                    nodeMark->setPrevious(newNode);
                    newNode->setPrevious(head);
                    
                } else if (nodeMark->getNext() == NULL && newContents > nodeMark->getContents()) {
                    nodeMark->setNext(newNode);
                    newNode->setPrevious(nodeMark);
                    tail = newNode;
                } else {
                    lagMark->setNext(newNode);
                    newNode->setNext(nodeMark);
                    nodeMark->setPrevious(newNode);
                    newNode->setPrevious(lagMark);
                }
                nodeMark = NULL;
                lagMark = NULL;
            }
        }
        newNode = NULL;
    }
}

bool DLList::removeFirst(int target) {
    DLNode* toRemove = NULL;
    DLNode* nodeMark = head;
    DLNode* lagMark = NULL;
    for (unsigned int i = 0; i < count; i++){
        if (nodeMark->getContents() != target && nodeMark->getNext() != NULL){
            lagMark = nodeMark;
            nodeMark = nodeMark->getNext();
        } else if (nodeMark->getContents() == target){
            toRemove = nodeMark;
        }
    }
    if (toRemove == NULL) {
        return false;
    }
    if (lagMark == NULL){
        popFront();
    } else if (toRemove->getNext() == NULL) {
        popBack();
    } else {
        count--;
        nodeMark = nodeMark->getNext();
        lagMark->setNext(nodeMark);
        nodeMark->setPrevious(lagMark);
        delete toRemove;
    }
    toRemove = NULL;
    nodeMark = NULL;
    lagMark = NULL;
    return true;
}

/**
 * create new DLNode with newContents and insert in ascending (based on 
 * newContents) order
 */
 void DLList::insert(int newContents) 
 {
    /**
     * Checks to see if head_ is null or if the contents of head_ are greater
     * then the parameter being inserted. If it is then calls the 
     * pushFront() function, otherwise continues to next check
     */
    if(head_ == NULL || head_->getContents() > newContents)
    {
        pushFront(newContents);
      /**
       * Checks if the contents of tail_ are less then the parameter being
       * inserted.  If so, calls pushBack() function, otherwise continues
       * to next check
       */
    } else if (tail_->getContents() < newContents)
    {
      pushBack(newContents);
      /**
       * Inserts the parameter into the correct location in the list
       */
    } else 
    {
      DLNode* iterator;
      iterator = head_;
      /**
       * Checks whether the contents of the next node is less then the parameter
       * and that the next node is not the tail.  If they are not, then it 
       * advances the iterator to the next node in the list
       */
      while(newContents > iterator->getNext()->getContents() && iterator->getNext() != tail_)
      {
        iterator = iterator->getNext();
      }
      /**
       * Checks if the iterator is located at the tail
       */
      if(iterator != tail_)
      {
        /**
         * If the iterator is not located at the tail, it creates a new node
         * and inserts it at the iterators current location, then increases
         * the size variable by 1
         */
        DLNode* new_node = new DLNode(newContents);
        new_node->setNext(iterator->getNext());
        //new_node->setPrevious(iterator);
        iterator->setNext(new_node);
        count_ = count_ + 1;
      } else
      {
        /**
         * If the iterator is located at the tail, then calls the InsertTail()
         * function
         */
        pushBack(newContents);
      }
    }
 }

/**
 * creates a new dynamic DLNode with the contents of 
 * the parameter and attaches as the new head of the list
 * @param string contents
 */
void DLList::pushFront(string contents)
{
    DLNode* temp = new DLNode(contents);
    temp->setNext(head_);
    temp->setPrevious(tail_);
    head_ = temp;
    size_ += 1;
    if (tail_ == NULL)
    tail_ = head_;
}

void DLList::pushFront(int value) {
  DLNode* newHead = new DLNode(value);
  if (head == NULL) {
    head = newHead;
    tail = head;
    size++;
  } else {
    newHead->setNext(head);
    head->setPrevious(newHead);
    head = newHead;
    size++;
  }
}

void DLList::popBack() {
    // Remove current head node; do nothing if list is empty
    if (tail_node != NULL) {
        DLNode* temp = head_node;
        DLNode* previous = temp;
        while(temp->getNext() != tail_node) {
            previous = temp;
            temp = temp->getNext();
        }
        previous->setNext(head_node);
        head_node->setPrevious(previous);
        delete tail_node;
        tail_node = previous;
        temp = NULL;
        node_count--;
    }
}

/**
  * Removes all occurences of the parameter
  * does nothing if not in list
  */
  bool DLList::removeAll(string contents)
  {
       //returns false for empty list
     if (head_ == NULL)
     {
         return false;
       // uses popBack() if tail == contents
     } else if (tail_->getContents() == contents)
     {
         popBack();
         return true;
     } else 
     {
         //creating pointers
         DLNode* iterator = head_, *temp = head_->getNext();
         //traverses to find match for contents
         while (contents != temp->getContents() && temp->getNext() != NULL)
         {
             temp = temp->getNext();
             iterator = iterator->getNext();
         }
     //returns false if contents are not in list
     if (temp == tail_ && temp->getContents() != contents)
     {
         return false;
     
     } else
     //checks if temp is the node to delete then executes
     while (temp != NULL)
     {
         if(temp->getContents() == contents)
         {
             iterator->setNext(temp->getNext());
             delete temp;
             size_ = size_ - 1;
             temp = NULL;
             
         }
     }
         
     } 
     return true;
  }

/**
 * removes the tail node from the list,
 * or does nothing if the list is empty
 */
void DLList::popBack()
{
    if (head_ != NULL)
    {
         if (head_ == tail_)
         {
             popFront();
         } else 
         {
             DLNode* temp = head_;
             while (temp->getNext() != tail_)
             temp = temp->getNext();
             temp->setNext(NULL);
             delete tail_;
             tail_ = temp;
             size_ -= 1;
         }
    }
}

void DLList::popBack() {
    if (head != NULL){
        if (head->getNext() == NULL) {
            popFront();
        } else {
            DLNode* i = head;
            DLNode* j = NULL;
            while (i->getNext() != NULL) {
                j = i;
                i = i->getNext();
            }
            if (i != NULL) {
                delete i;
                j->setNext(NULL);
                tail = j;
            }
            count--;
        }
    }
}

bool DLList::removeFirst(string target) {
    if(head_node == NULL) {
        return false;
    }
    
    DLNode* temp = head_node;
    DLNode* previous = temp;
    if(head_node->getContents() == target) {
        cout << "Eliminated " << target << endl;
        popFront();
        return true;
    }
    if(tail_node->getContents() == target) {
        cout << "Eliminated " << target << endl;
        popBack();
        return true;
    }
    // There is no reason why this loop would be endless, so there won't be a catch.
    // The incoming TARGET string is only called when getStop finishes.
    while(temp->getContents() != target) {
        // Get next node and continue, and keep previous 1 behind.
        previous = temp;
        temp = temp->getNext();
    }
    
    if(temp->getContents() == target) {
        cout << "Eliminated " << target << endl;
        // Delete Node
        // Setting previous' node to the next node of temp
        previous->setNext(temp->getNext());
        // Setting temp's next node's PREVIOUS to temp's previous NODE
        temp->setPrevious(temp->getPrevious());
        delete temp;
        temp = NULL;
        node_count--;
        return true;
    } else {
        cout << "RemoveFirst returned false entirely (bad?)"<<endl;return false;}
}

void DLList::insert(string newContents) {
    // Inserts New Node with newContents and attach in order
    string placeholder = newContents;
    char check_place = newContents[0];
    char check_head;
    char check_tail;
    if(head_node != NULL) {
        string head_contents = head_node->getContents();
        check_head = head_contents[0];
        string tail_contents = tail_node->getContents();
        check_tail = tail_contents[0];
    }
    
    if(head_node == NULL || ((check_place <= check_head) && (head_node != NULL))) {
        cout <<  "    Creating new head node:" << newContents << endl;
        pushFront(newContents);
    }
    else if(tail_node == NULL || ((check_place >= check_tail) && (tail_node != NULL))) {
        cout <<  "    Creating new tail node:" << newContents << endl;
        pushBack(newContents);
    }
    else
    {
        DLNode* temp = head_node;
        DLNode* previous = temp;
        
        while(temp->getContents() < newContents) {
            previous = temp;
            temp = temp->getNext();
        }
        
        DLNode* new_node = new DLNode(newContents);
        new_node->setNext(temp);
        previous->setNext(new_node);
        node_count = node_count + 1;
    }
}

void DLList::pushBack(int newContents) {
    if (head == NULL) {
        pushFront(newContents);
    } else {
        DLNode* newTail = new DLNode(newContents);
        if (head->getNext() == NULL) {
            head->setNext(newTail);
            newTail->setPrevious(head);
        } else {
            DLNode* oldTail = head->getNext();
            for (unsigned int i = 1; i < count; i++){
                if (oldTail-> getNext() != NULL){
                    oldTail = oldTail->getNext();
                }
            }
            oldTail->setNext(newTail);
            newTail->setPrevious(oldTail);
            oldTail = NULL;
        }
        tail = newTail;
        newTail = NULL;
        count++;
    }
}