doxygen/mp3/List_8hpp_source.html

 template <typename T>
 typename List<T>::ListIterator List<T>::begin() const {
   // @TODO: graded in MP3.1
   return List<T>::ListIterator(nullptr);
 }

 template <typename T>
 typename List<T>::ListIterator List<T>::end() const {
   // @TODO: graded in MP3.1
   return List<T>::ListIterator(nullptr);
 }

 template <typename T>
 List<T>::~List() {
 }

 template <typename T>
 void List<T>::_destroy() {
 }

 template <typename T>
 void List<T>::insertFront(T const & ndata) {
 }

 template <typename T>
 void List<T>::insertBack(const T & ndata) {
 }

 template <typename T>
 void List<T>::reverse() {
   reverse(head_, tail_);
 }

 template <typename T>
 void List<T>::reverse(ListNode *& startPoint, ListNode *& endPoint) {
 }

 template <typename T>
 void List<T>::reverseNth(int n) {
 }

 template <typename T>
 void List<T>::waterfall() {
 }

 template <typename T>
 List<T> List<T>::split(int splitPoint) {
     if (splitPoint > length_)
         return List<T>();

     if (splitPoint < 0)
         splitPoint = 0;

     ListNode * secondHead = split(head_, splitPoint);

     int oldLength = length_;
     if (secondHead == head_) {
         // current list is going to be empty
         head_ = NULL;
         tail_ = NULL;
         length_ = 0;
     } else {
         // set up current list
         tail_ = head_;
         while (tail_ -> next != NULL)
             tail_ = tail_->next;
         length_ = splitPoint;
     }

     // set up the returned list
     List<T> ret;
     ret.head_ = secondHead;
     ret.tail_ = secondHead;
     if (ret.tail_ != NULL) {
         while (ret.tail_->next != NULL)
             ret.tail_ = ret.tail_->next;
     }
     ret.length_ = oldLength - splitPoint;
     return ret;
 }

 template <typename T>
 typename List<T>::ListNode * List<T>::split(ListNode * start, int splitPoint) {
   return NULL;
 }

 template <typename T>
 void List<T>::mergeWith(List<T> & otherList) {
     // set up the current list
     head_ = merge(head_, otherList.head_);
     tail_ = head_;

     // make sure there is a node in the new list
     if (tail_ != NULL) {
         while (tail_->next != NULL)
             tail_ = tail_->next;
     }
     length_ = length_ + otherList.length_;

     // empty out the parameter list
     otherList.head_ = NULL;
     otherList.tail_ = NULL;
     otherList.length_ = 0;
 }

 template <typename T>
 typename List<T>::ListNode * List<T>::merge(ListNode * first, ListNode* second) {
   return NULL;
 }

 template <typename T>
 void List<T>::sort() {
     if (empty())
         return;
     head_ = mergesort(head_, length_);
     tail_ = head_;
     while (tail_->next != NULL)
         tail_ = tail_->next;
 }

 template <typename T>
 typename List<T>::ListNode* List<T>::mergesort(ListNode * start, int chainLength) {
   return NULL;
 }
List::end
ListIterator end() const
Returns a ListIterator one past the end of the List.
Definition: List.hpp:21

List::_destroy
void _destroy()
Destroys all dynamically allocated memory associated with the current List class. ...
Definition: List.hpp:40

List::~List
~List()
Destroys the current List.
Definition: List.hpp:31

List::tail_
ListNode * tail_
The tail of the list.
Definition: List.h:223

List::begin
ListIterator begin() const
Returns a ListIterator with a position at the beginning of the List.
Definition: List.hpp:12

List::mergeWith
void mergeWith(List< T > &otherList)
Merges the given sorted list into the current sorted list.
Definition: List.hpp:182

List::length_
int length_
The length of the current List.
Definition: List.h:228

List::merge
ListNode * merge(ListNode *first, ListNode *second)
Helper function to merge two sorted and independent sequences of linked memory.
Definition: List.hpp:212

List::reverse
void reverse()
Reverses the current List.
Definition: List.hpp:70

List
List: This is a templated linked list class (meaning it contains data of templated type T...
Definition: List.h:21

List::mergesort
ListNode * mergesort(ListNode *start, int chainLength)
Sorts a chain of linked memory given a start node and a size.
Definition: List.hpp:240

List::ListNode
The ListNode class is private to the List class via the principle of encapsulation—the end user does...
Definition: List.h:28

List::head_
ListNode * head_
The head of the List.
Definition: List.h:218

List::insertFront
void insertFront(const T &ndata)
Inserts a new node at the front of the List.
Definition: List.hpp:51

List::insertBack
void insertBack(const T &ndata)
Inserts a new node at the back of the List.
Definition: List.hpp:62

List::split
List< T > split(int splitPoint)
Splits the given list into two parts by dividing it at the splitPoint.
Definition: List.hpp:122

List::sort
void sort()
Sorts the current list by applying the Mergesort algorithm.
Definition: List.hpp:221

List::reverseNth
void reverseNth(int n)
Reverses blocks of size n in the current List.
Definition: List.hpp:97

List::waterfall
void waterfall()
Modifies the List using the waterfall algorithm.
Definition: List.hpp:111