Remove a node from doubly linked list given its position

[tomtran43]

Hi, I am trying to remove a node given its position from a doubly linked list. My other functions work fine, only remove function is wrong. Can anyone please tell me how to fix it?

  #ifndef DLIST_H
#define DLIST_H

#include <ostream>
#include <stdexcept>

using namespace std;

template <class T>
struct node_t {
  T data;
  node_t<T>* prev;
  node_t<T>* next;
};

template <class T>
class DList{

  public:
  DList(){
   head = NULL;
   tail = NULL;
   my_size = 0;
  }
  
  ~DList(){
		node_t<T>* temp = head;
    while(temp){
      node_t<T>* to_delete = temp;
      temp = temp->next;
      delete to_delete;
    }
    head = NULL;
    tail = NULL;
    my_size = 0;
	}
	
  DList(const DList<T>& other){
    head = NULL;
    tail = NULL;
    my_size = 0;
    node_t<T>* temp = other.head;
    while(temp){
      push_back(temp->data);
      temp = temp->next;
    }
  }
	
	// Similar to copy constructor, but check for self
	// assignment, if not, clear and copy all data.
  DList<T>& operator= (const DList& other){
		if(this != &other){
		  clear();
		  head = NULL;
		  my_size = 0;
		  node_t<T>* temp = other.head;
		  while(temp){
        push_back(temp->data);
        temp = temp->next;
      }
    }
    return *this;
	}
     
  T getAt(int pos) const{
    if(pos < 0) {
      pos = size() + pos;
    }

    if(pos < 0) {
      throw logic_error("Error");
    }

    node_t<T>* temp;

    if(pos <= (int) size()/2) {
      temp = head;
      while(temp && pos > 0) {
        pos--;
        temp = temp->next;
      }
    } else if(pos < (int) size()) {
      pos = size() - pos - 1;
      temp = tail;
      while(temp && pos > 0) {
        pos--;
        temp = temp->prev;
      }
    } else {
      throw logic_error("Error");
    }

    if(!temp) {
      throw logic_error("Error");
    }

   return temp->data;
  }

  unsigned int size() const{
    return my_size;
  }
 
  void push_back(T value){
    node_t<T>* temp = new node_t<T>;
    temp->data = value;
    temp->next = NULL;
    temp->prev = tail;
    if(tail){
      tail->next = temp;
    }
    tail = temp;
    if(!tail->prev){
      head = tail;
    }
    my_size++;
  }
  
  void push_front(T value){
    node_t<T>* temp = new node_t<T>;
    temp->data = value;
    temp->prev = NULL;
    temp->next = head;
    if(head){
      head->prev = temp;
    }
    head = temp;
    if(!head->next){
      tail = head;
    }
    my_size++;
  }
	
	void setAt(T value, int pos){
	  if(pos < 0) {
      pos = size() + pos;
    }

    if(pos < 0) {
      throw logic_error("Error");
    }

    node_t<T>* temp;

    if(pos <= (int) size()/2) {
      temp = head;
      while(temp && pos > 0) {
        pos--;
        temp = temp->next;
      }
    } else if(pos < (int) size()) {
      pos = size() - pos - 1;
      temp = tail;
      while(temp && pos > 0) {
        pos--;
        temp = temp->prev;
      }
    } else {
      throw logic_error("Error");
    }

    if(!temp) {
      throw logic_error("Error");
    }
    temp->data = value;
    return;
  }
	
	void remove(int pos){
	  if(pos < 0){
	    pos = pos + size();
	  }
	  if((unsigned int) pos >= my_size){
	    throw logic_error("Error");
	  }
	  if(pos == 0){
	    node_t<T>* temp = head;
	    head = head->next;
	    temp->next = NULL;
	    delete temp;
	    my_size--;
	    return;
	  }
	  else if(pos == size()-1){
	    node_t<T>* temp = tail;
	    tail = tail->prev;
	    temp->prev = NULL;
	    delete temp;
	    my_size--;
	    return;
	  }
	  else{
	  node_t<T>* temp = head;
	  while(temp->next != NULL && pos > 1){
	    temp = temp->next;
	    pos--;
	  }
	  if(temp->next != NULL){
	    node_t<T>* temp2 = temp->next;
	    temp->next = temp->next->next;
	    temp2->next = NULL;
	    delete temp2;
	    my_size--;
	  }
	  }
	}
	
	DList<T> reverse() const{
		DList<T> ret;
		node_t<T>* temp = head;
		while(temp){
		  ret.push_front(temp->data);
		  temp = temp->next;
		}
		return ret;
	}
	
	DList<T> operator+(const DList<T>& rhs) const{
		DList<T> ret;
	  node_t<T>* temp = head;
	  while(temp){
	    ret.push_front(temp->data);
	    temp = temp->next;
	  }
	  temp = rhs.head;
	  while(temp){
	    ret.push_back(temp->data);
	    temp = temp->next;
	  }
	  return ret;
	}
	
	bool operator==(const DList<T>& rhs) const{
	  if(size() != rhs.size()){
	    return false;
	  }
	  node_t<T>* cur = head;
	  node_t<T>* other = rhs.head;
	  while(cur != NULL && other != NULL){
	    if(cur->data != other->data){
	      return false;
	    }
	    cur = cur->next;
	    other = other->next;
	  }
	  if( cur != NULL || other != NULL){
	    return false;
	  }
	  return true;;
	}
	
	bool operator!=(const DList<T>& rhs) const{
		return !(*this == rhs);
	}
	
	void clear(){
		node_t<T>* temp = head;
		while(temp != NULL){
		  node_t<T>* to_delete = temp;
		  temp = temp->next;
		  delete to_delete;
		}
		head = NULL;
		tail = NULL;
		my_size = 0;
	}
	
  private:
  node_t<T>* head;
  node_t<T>* tail;
  unsigned int my_size;
};
template <class T>
ostream& operator<<(ostream& out, const DList<T> thing){
	out << "[";
	for(unsigned int i = 0; i < thing.size(); i++){
    if(i < thing.size() - 1){
      out << thing.getAt(i) << ", ";
    }
    else{
      out << thing.getAt(i);
    }
  }
  out <<"]";
	return out;
}


#endif 

[coder777]

I suggest that you create a FindAt(...) function. Thus you can avoid the code replication in getAt(...) and setAt(...). Use FindAt(...) in remove(...) as well.

Note that
found_node->prev == NULL means that it is head
and
found_node->next == NULL means that it is tail