Question

需要反转列表然后将其打印出来，截至目前它按照相同的顺序打印列表，我一直在搜索，但我仍然卡住了。我甚至都不知道它是否正在逆转。非常感谢任何帮助。

#include <string>
#include <iostream>
#include <cassert>
#include <list>

using namespace std;

class List;
class Iterator;

class Node{
public:
   /** 
      Constructs a node with a given data value.
      @param s the data to store in this node
   */
   Node(string s);
private:
   string data;
   Node* previous;
   Node* next;
friend class List;
friend class Iterator;
};

class List{
public:
   /**
      Constructs an empty list;
   */
   List();
   /**
      Appends an element to the list.
      @param data the value to append
   */
   void push_back(string data);
   /**
      Inserts an element into the list.
      @param iter the position before which to insert
      @param s the value to append
   */
   void insert(Iterator iter, string s);
   /**
      Reverses the order of the elements in the list.
   */
   void reverse(Node *&head);
   /**
      Removes an element from the list.
      @param iter the position to remove
      @return an iterator pointing to the element after the
      erased element
   */
   Iterator erase(Iterator iter);
   /**
      Gets the beginning position of the list.
      @return an iterator pointing to the beginning of the list
   */
   Iterator begin();
   /**
      Gets the past-the-end position of the list.
      @return an iterator pointing past the end of the list
   */
   Iterator end();
private:
   Node* first;
   Node* last;
friend class Iterator;
};

class Iterator{
public:
   /**
      Constructs an iterator that does not point into any list.
   */
   Iterator();
   /**  
      Looks up the value at a position.
      @return the value of the node to which the iterator points
   */
   string get() const;
   /**
      Advances the iterator to the next node.
   */
   void next();
   /**
      Moves the iterator to the previous node.
   */
   void previous();
   /**
      Compares two iterators
      @param b the iterator to compare with this iterator
      @return true if this iterator and b are equal
   */
   bool equals(Iterator b) const;
private:
   Node* position;
   List* container;
friend class List;
};

Node::Node(string s){  
   data = s;
   previous = NULL;
   next = NULL;
}

List::List(){  
   first = NULL;
   last = NULL;
}

void List::push_back(string data){  
   Node* new_node = new Node(data);
   if (last == NULL) // List is empty
   {  
      first = new_node;
      last = new_node;
   }
   else{  
      new_node->previous = last;
      last->next = new_node;
      last = new_node;
   }
}

void List::insert(Iterator iter, string s){  
   if (iter.position == NULL)   {  
      push_back(s);
      return;
   }

   Node* after = iter.position;
   Node* before = after->previous;
   Node* new_node = new Node(s);
   new_node->previous = before;
   new_node->next = after;
   after->previous = new_node;
   if (before == NULL) // Insert at beginning
      first = new_node;
   else
      before->next = new_node;
}

void List::reverse(Node *&head){
    if((head == NULL)||(head->next=NULL))
        return;
    Node *top = head;
    Node *tail = NULL;
    Node *curr = head;
    Node *temp = NULL;

    while(curr != NULL){
        temp = curr->next;
        curr->next = curr->previous;
        curr->previous = temp;
        if(temp == NULL){
            tail = curr;
        }
        curr = temp;
    } 
    temp = head;
    head = tail;
    tail = temp;
}

Iterator List::erase(Iterator iter){  
   assert(iter.position != NULL);
   Node* remove = iter.position;
   Node* before = remove->previous;
   Node* after = remove->next;
   if (remove == first)
      first = after;
   else
      before->next = after;
   if (remove == last)
      last = before;
   else
      after->previous = before;
   delete remove;
   Iterator r;
   r.position = after;
   r.container = this;
   return r;
}

Iterator List::begin(){  
   Iterator iter;
   iter.position = first;
   iter.container = this;
   return iter;
}

Iterator List::end(){  
   Iterator iter;
   iter.position = NULL;
   iter.container = this;
   return iter;
}

Iterator::Iterator(){  
   position = NULL;
   container = NULL;
}

string Iterator::get() const{  
   assert(position != NULL);
   return position->data;
}

void Iterator::next(){  
   assert(position != NULL);
   position = position->next;
}

void Iterator::previous(){  
   assert(position != container->first);
   if (position == NULL)
      position = container->last;
   else 
      position = position->previous;
}

bool Iterator::equals(Iterator b) const{  
   return position == b.position;
}

int main(){

   List staff;

   // Add orginal values to staff
   staff.push_back("Tom");
   staff.push_back("Dick");
   staff.push_back("Harry");
   staff.push_back("Juliet");

   Iterator pos;

   // Print all values
   for (pos = staff.begin(); !pos.equals(staff.end()); pos.next())
      cout << pos.get() << "\n";

   // Reverse the values
    Node* head = NULL;
    staff.reverse(head);

   // Print all values to show reverse
   cout << endl;
   for (pos = staff.begin(); !pos.equals(staff.end()); pos.next())
      cout << pos.get() << "\n";

   return 0;
}

Answer 1

迭代地反转链表... 遍历到最后一个节点并将其从列表中删除并使其成为头部。对于将它们附加到此新链接列表的所有节点重复此操作

Answer 2

那么，List::reverse方法的第一个语句会检查head == NULL是否为NULL，如果是，则返回而不修改列表。你正在传递head。所以这显然是一个问题。我不明白为什么你认为你需要传递一个first参数，但如果你需要，你可能想要将它初始化为列表的{{1}}。

反转链表 - 迭代

2 个答案: