here is the coding which will show the highest gpa which it will data from txt file, i dun knw how Modify the below program to sort the students’ GPA in an ascending order using bubble sorting.
example input is
3.5 Bill
3.6 John
2.7 Lisa
3.9 Kathy
3.4 Jason
3.9 David
3.4 Jack
example output
2.7 Lisa
3.4 Jason
3.4 Jack
3.5 Bill
3.6 John
3.9 Kathy
3.9 David
#ifndef H_StackType
#define H_StackType
#include <iostream>
#include <cassert>
usingnamespace std;
template<class Type>
class stackType
{
public:
const stackType<Type>& operator=(const stackType<Type>&);
//Overload the assignment operator.
void initializeStack();
//Function to initialize the stack to an empty state.
//Postcondition: stackTop = 0
bool isEmptyStack();
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty;
// otherwise, returns false.
bool isFullStack();
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full;
// otherwise, returns false.
void destroyStack();
//Function to remove all the elements from the stack.
//Postcondition: stackTop = 0
void push(const Type& newItem);
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of stack.
Type top();
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element
// of the stack is returned.
void pop();
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
stackType(int stackSize = 100);
//constructor
//Creates an array of the size stackSize to hold the
//stack elements. The default stack size is 100.
//Postcondition: The variable list contains the base
// address of the array, stackTop = 0, and
// maxStackSize = stackSize.
stackType(const stackType<Type>& otherStack);
//copy constructor
~stackType();
//destructor
//Removes all the elements from the stack.
//Postcondition: The array (list) holding the stack
// elements is deleted.
private:
int maxStackSize; //variable to store the maximum stack size
int stackTop; //variable to point to the top of the stack
Type *list; //pointer to the array that holds the
//stack elements
void copyStack(const stackType<Type>& otherStack);
//Function to make a copy of otherStack.
//Postcondition: A copy of otherStack is created and
// assigned to this stack.
};
template<class Type>
void stackType<Type>::initializeStack()
{
stackTop = 0;
}//end initializeStack
template<class Type>
void stackType<Type>::destroyStack()
{
stackTop = 0;
}//end destroyStack
template<class Type>
bool stackType<Type>::isEmptyStack()
{
return(stackTop == 0);
}//end isEmptyStack
template<class Type>
bool stackType<Type>::isFullStack()
{
return(stackTop == maxStackSize);
} //end isFullStack
template<class Type>
void stackType<Type>::push(const Type& newItem)
{
if(!isFullStack())
{
list[stackTop] = newItem; //add newItem at the
//top of the stack
stackTop++; //increment stackTop
}
else
cerr<<"Cannot add to a full stack."<<endl;
}//end push
template<class Type>
Type stackType<Type>::top()
{
assert(stackTop != 0); //if stack is empty,
//terminate the program
return list[stackTop - 1]; //return the element of the
//stack indicated by
//stackTop - 1
}//end top
template<class Type>
void stackType<Type>::pop()
{
if(!isEmptyStack())
stackTop--; //decrement stackTop
else
cerr<<"Cannot remove from an empty stack."<<endl;
}//end pop
template<class Type>
stackType<Type>::stackType(int stackSize)
{
if(stackSize <= 0)
{
cerr<<"Size of the array to hold the stack must "
<<"be positive."<<endl;
cerr<<"Creating an array of size 100."<<endl;
maxStackSize = 100;
}
else
maxStackSize = stackSize; //set the stack size to
//the value specified by
//the parameter stackSize
stackTop = 0; //set stackTop to 0
list = new Type[maxStackSize]; //create the array to
//hold the stack elements
assert(list != NULL);
}//end constructor
template<class Type>
stackType<Type>::~stackType() //destructor
{
delete [] list; //deallocate memory occupied by the array
}//end destructor
template<class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{
delete [] list;
maxStackSize = otherStack.maxStackSize;
stackTop = otherStack.stackTop;
list = new Type[maxStackSize];
assert(list != NULL);
//copy otherStack into this stack
for(int j = 0; j < stackTop; j++)
list[j] = otherStack.list[j];
} //end copyStack
template<class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
list = NULL;
copyStack(otherStack);
}//end copy constructor
template<class Type>
const stackType<Type>& stackType<Type>::operator=
(const stackType<Type>& otherStack)
{
if(this != &otherStack) //avoid self-copy
copyStack(otherStack);
return *this;
} //end operator=
#endif
