LinkedList实现类

LinkedList实现类

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include 
   
   
    
    
using namespace std;

template
    
    
     
     
class Node
{
public:
  T element;  // Element contained in the node
  Node
     
     
      
       *next; // Pointer to the next node

  Node() // No-arg constructor
  {
    next = NULL;
  }

  Node(T element) // Constructor
  {
    this->element = element;
    next = NULL;
  }
};

template
      
      
       
       
class LinkedList
{
public:
  LinkedList();
  void addFirst(T element);
  void addLast(T element);
  T getFirst();
  T getLast();
  T removeFirst() throw (runtime_error);
  T removeLast();
  void add(T element);
  void add(int index, T element);
  void clear();
  bool contains(T element);
  T get(int index);
  int indexOf(T element);
  bool isEmpty();
  int lastIndexOf(T element);
  bool remove(T element);
  int getSize();
  T removeAt(int index);
  T set(int index, T element);

private:
  Node
       
       
         *head, *tail; int size; }; template 
        
          LinkedList 
         
           ::LinkedList() { head = tail = NULL; size = 0; } template 
          
            void LinkedList 
           
             ::addFirst(T element) { Node 
            
              *newNode = new Node 
             
               (element); newNode->next = head; head = newNode; size++; if (tail == NULL) tail = head; } template 
              
                void LinkedList 
               
                 ::addLast(T element) { if (tail == NULL) { head = tail = new Node 
                
                  (element); } else { tail->next = new Node 
                 
                   (element); tail = tail->next; } size++; } template 
                  
                    T LinkedList 
                   
                     ::getFirst() { if (size == 0) throw runtime_error("Index out of range"); else return head->element; } template 
                    
                      T LinkedList 
                     
                       ::getLast() { if (size == 0) throw runtime_error("Index out of range"); else return tail->element; } template 
                      
                        T LinkedList 
                       
                         ::removeFirst() throw (runtime_error) { if (size == 0) throw runtime_error("No elements in the list"); else { Node 
                        
                          *temp = head; head = head->next; size--; if (head == NULL) tail = NULL; T element = temp->element; delete temp; return element; } } template 
                         
                           T LinkedList 
                          
                            ::removeLast() { if (size == 0) throw runtime_error("No elements in the list"); else if (size == 1) { Node 
                           
                             *temp = head; head = tail = NULL; size = 0; T element = temp->element; delete temp; return element; } else { Node 
                            
                              *current = head; for (int i = 0; i < size - 2; i++) current = current->next; Node 
                             
                               *temp = tail; tail = current; tail->next = NULL; size--; T element = temp->element; delete temp; return element; } } template 
                              
                                void LinkedList 
                               
                                 ::add(T element) { addLast(element); } template 
                                
                                  void LinkedList 
                                 
                                   ::add(int index, T element) { if (index == 0) addFirst(element); else if (index >= size) addLast(element); else { Node 
                                  
                                    *current = head; for (int i = 1; i < index; i++) current = current->next; Node 
                                   
                                     *temp = current->next; current->next = new Node 
                                    
                                      (element); (current->next)->next = temp; size++; } } template 
                                     
                                       void LinkedList 
                                      
                                        ::clear() { while (head != NULL) { Node 
                                       
                                         *temp = head; delete temp; head = head->next; } tail = NULL; } template 
                                        
                                          T LinkedList 
                                         
                                           ::get(int index) { if (index < 0 || index > size - 1) throw runtime_error("Index out of range"); Node 
                                          
                                            *current = head; for (int i = 0; i < index; i++) current = current->next; return current->element; } template 
                                           
                                             int LinkedList 
                                            
                                              ::indexOf(T element) { // Implement it in this exercise Node 
                                             
                                               *current = head; for (int i = 0; i < size; i++) { if (current->element == element) return i; current = current->next; } return -1; } template 
                                              
                                                bool LinkedList 
                                               
                                                 ::isEmpty() { return head == NULL; } template 
                                                
                                                  int LinkedList 
                                                 
                                                   ::getSize() { return size; } template 
                                                  
                                                    T LinkedList 
                                                   
                                                     ::removeAt(int index) { if (index < 0 || index >= size) throw runtime_error("Index out of range"); else if (index == 0) return removeFirst(); else if (index == size - 1) return removeLast(); else { Node 
                                                    
                                                      *previous = head; for (int i = 1; i < index; i++) { previous = previous->next; } Node 
                                                     
                                                       *current = previous->next; previous->next = current->next; size--; T element = current->element; delete current; return element; } } // The functions remove(T element), lastIndexOf(T element), // contains(T element), and set(int index, T element) are // left as an exercise #endif