// Nathan Lutz
// File: studgradelnklist.cpp.  Contents: C++ source code for dynamic memory
// allocation implementation of a list of grades.  Each node in the list 
// contains a grade and the occurrence count for that grade.
// The grades are stored in ascending order.
//

#include "gradelnklist.h"
#include <iostream>
#include <iomanip>
using namespace std;

// ---------- general list members first ----------

// --------------------------------------------------------------------
// GradeList constructor -  initializes a list to empty
// --------------------------------------------------------------------
// Accepts:  nothing
// Returns:  nothing
// --------------------------------------------------------------------

GradeList::GradeList()
{
head = NULL;
}

// --------------------------------------------------------------------
// GradeList destructor - deletes all nodes in list
// --------------------------------------------------------------------
// Accepts:  nothing
// Returns:  nothing
// --------------------------------------------------------------------

GradeList::~GradeList()
{
NodeType* tmp;    // temp ptr for deleting nodes

while (head != NULL)    // destroy nodes one by one
{
    tmp = head;
    head = head->next;
    delete tmp;
}
}

// --------------------------------------------------------------------
// IsEmpty - test for empty list
// --------------------------------------------------------------------
// Accepts:  nothing
// Returns:  true if the list is empty, false otherwise.
// --------------------------------------------------------------------

bool GradeList::IsEmpty(void)
{
return (head == NULL);
}

// --------------------------------------------------------------------
// IsFull - test for full list
// --------------------------------------------------------------------
// Accepts:  nothing
// Returns:  false always, because, within the bounds of memory size,
//           the list never fills!
// --------------------------------------------------------------------

bool GradeList::IsFull()
{
return false;
}

// -------------------------------------------------------------------
// Display - prints the grades in the list, one grade per line
// -------------------------------------------------------------------
// Accepts:  nothing
// Returns:  nothing
// -------------------------------------------------------------------

void GradeList::Display()
{
NodeType* tmp = head;   // temp ptr for traversing list

if (IsEmpty())
    cout << "\nThere are no grades\n\n";
else
{
    cout << "\nGrades    Num of Each \n\n";
    while (tmp != NULL)
    {
        cout << setw(4) << tmp->grade << setw(14) << tmp->count << "\n";
        tmp = tmp->next;
    }
}

}

// -------------------------------------------------------------------
// Function to insert a new grade into the list in ascending order
// -------------------------------------------------------------------
// Accepts:  the new grade
// Returns:  nothing
// -------------------------------------------------------------------

void GradeList::InsertGrade(int newgrade)
{
NodeType* curr = head;   // temp ptr for traversing list
NodeType* prev = NULL;   // temp ptr for traversing list
NodeType* tmp;           // temp ptr to create new node

while (curr != NULL && curr->grade < newgrade)  // find place to insert
{
    prev = curr;
    curr = curr->next;
}

if (curr != NULL && curr->grade == newgrade)    // grade already here ...
    curr->count++;                              // ... simply inc. count
else
    if (prev == NULL)    // empty list or insert at beginning
    {
        tmp = new NodeType;
        tmp->grade = newgrade;
	tmp->count = 1;
	tmp->next = head;
	head = tmp;
    }
    else                 // insert in middle or at end
    {
	tmp = new NodeType;
	tmp->grade = newgrade;
	tmp->count = 1;
	tmp->next = curr;
        prev->next = tmp;
    }
}

// -------------------------------------------------------------------
// Function to delete the indicated grade from the list
// -------------------------------------------------------------------
// Accepts:  grade to delete
// Returns:  nothing
// -------------------------------------------------------------------

void GradeList::DeleteGrade(int delgrade)
{
    NodeType* curr = head;   // temp ptr for traversing list
    NodeType* prev = NULL;   // temp ptr for traversing list

    while (curr != NULL && curr->grade < delgrade)  // find place to delete
    {
    	prev = curr;
    	curr = curr->next;
    }

    if (curr != NULL && curr->grade == delgrade)    // grade found
    {
	curr->count--;                              // dec. count
    	if(curr->count==0)
	{
		if (prev == NULL)    // delete at beginning
    		{
     			head = curr->next;
        		delete curr;
    		}
    		else                 // delete at middle or at end
    		{
			prev->next = curr->next;
        		delete curr;
    		}

    	}
    }
}

// -------------------------------------------------------------------
// Function to calculate the average of the grades in the list
// -------------------------------------------------------------------
// Accepts:  nothing
// Returns:  the average (0 if list is empty)
// -------------------------------------------------------------------

float GradeList::CalculateAvg()
{
	NodeType* curr = head;   // temp ptr for traversing list
	NodeType* prev = NULL;   // temp ptr for traversing list
	NodeType* tmp;           // temp ptr to create new node

	float sum = 0.0;
        int total = 0;
        while(curr!=NULL)
	{
                sum=sum+(curr->grade*curr->count);
                total+=curr->count;
		curr=curr->next;
        }
	if(total!=0)		// tests to see if the list is empty
        sum=sum/total;
        return sum;		// returns the average of the grades, 0.0 if list is empty
}

// -------------------------------------------------------------------
// DropLowestGrade - drops the lowest grade in the list, does nothing
//                   if list is empty
// -------------------------------------------------------------------
// Accepts:  nothing
// Returns:  nothing
// -------------------------------------------------------------------

void GradeList::DropLowestGrade()
{
	NodeType* curr = head;   // temp ptr for traversing list
        NodeType* prev = NULL;   // temp ptr for traversing list
       				
        if(curr!=NULL)
	{
		curr->count--;	// dec. count
		if(curr->count==0)
        	{
	               	if (prev == NULL)    // delete at beginning
	               	{
       	        	        head = curr->next;
        	       	        delete curr;
        		}
 		}
	}

}
     
// -------------------------------------------------------------------
// HowManyofGrade -  returns how many times this grade is in the list
// -------------------------------------------------------------------
// Accepts:  the grade to look for
// Returns:  the number of times the grade is in the list
// -------------------------------------------------------------------

int GradeList::HowManyofGrade (int sgrade)
{
        NodeType* curr = head;   // temp ptr for traversing list
        NodeType* prev = NULL;   // temp ptr for traversing list
	if(curr != NULL)
	{
		while (curr != NULL && curr->grade < sgrade)  	// search for grade
        	{
        		prev = curr;	
        		curr = curr->next;
        	}
		return curr->count;				// return count of grade
	}
	else
		return 0;
}