sicily 1000. LinkedList

Description

template <typename E>

class LinkedList

{

private:

 

  // inner class: linked-list node

  class Node

  {

  public:

    E data;

    Node * next;

  };

 

  Node * first;

 

public:

  LinkedList() {

    first = 0;

  }

 

  ~LinkedList() {

    while (first != 0) {

      removeFirst();

    }

  }

 

  E getFirst() {

    return first->data;

  }

 

  bool isEmpty() {

    return first == 0;

  }

 

// 实现下列4个函数:

  LinkedList(const LinkedList & that);

  LinkedList & operator= (const LinkedList & that);

  void removeFirst() ;

  void addFirst(E data);

};

Hint

链表的插入使用头插法，只需提交模板类函数的实现即可，不需要提交main函数，如下列代码所示：

template <typename E>

void LinkedList<E>::removeFirst()

{

    Node * node = first;

    first = node->next;

    delete node;

}

 

代码如下：

template <typename E>
LinkedList<E>::LinkedList(const LinkedList & that) {
    Node* current = ;
    Node* node = that.first;
    while (node != ) {
        if (current == ) current= first = new Node();
        else {
            current->next = new Node();
            current = current->next;
        }
        current->data = node->data;
        current->next = ;
        node = node->next;
    }
}

template <typename E>
LinkedList<E>& LinkedList<E>::operator= (const LinkedList & that) {
    LinkedList<E> tmp(that);
    while (first != ) removeFirst();
    Node* current = ;
    Node* node = tmp.first;
    while (node != ) {
        if (current == ) current= first = new Node();
        else {
            current->next = new Node();
            current = current->next;
        }
        current->data = node->data;
        current->next = ;
        node = node->next;
    }
    return *this;
}

template <typename E>
void LinkedList<E>::removeFirst()
{
    Node * node = first;
    first = node->next;
    delete node;
}

template <typename E>
void LinkedList<E>::addFirst(E data) {
    Node* newFirst = new Node();
    newFirst->data = data;
    newFirst->next = first;
    first = newFirst;
}

测试代码：

template <typename E>
class LinkedList
{
private:

  // inner class: linked-list node
  class Node
  {
  public:
    E data;
    Node * next;
  };

  Node * first;

public:
  LinkedList() {
    first = ;
  }

  ~LinkedList() {
    while (first != ) {
      removeFirst();
    }
  }

  E getFirst() {
    return first->data;
  }

  bool isEmpty() {
    return first == ;
  }

// TODO:
  LinkedList(const LinkedList & that);
  LinkedList & operator= (const LinkedList & that);
  void removeFirst() ;
  void addFirst(E data);
};

/*template <typename E>
LinkedList<E>::LinkedList(const LinkedList<E> & that)
{

}

template <typename E>
LinkedList<E> & LinkedList<E>::operator= (const LinkedList<E> & that)
{

}

template <typename E>
void LinkedList<E>::removeFirst() {
    Node * node = first;
    first = node->next;
    delete node;
}

template <typename E>
void LinkedList<E>::addFirst(E data)
{

}

*/

//#include "source.cpp"

#include <iostream>
using namespace std;

LinkedList<double> read() {
  LinkedList<double> list;
  for (int i = ; i < ; ++ i) {
    double value;
    cin >> value;
    list.addFirst(value);
  }
  return list;
}

void removeAndPrintAll(LinkedList<double> list) {
  while (! list.isEmpty()) {
    cout << list.getFirst() << endl;
    list.removeFirst();
  }
}

int main() {
  LinkedList<double> list = read();
  LinkedList<double> list2;
  list2 = list;
  removeAndPrintAll(list2);
}