Repl.it Solution

//	LinkedBag340.cpp
//	Created by: CSC340

#include<iostream>
#include<cstddef>
#include<ctime>
#include<cstdlib>
#include"LinkedBag.h"



//  removeSecondNode340()
template<typename ItemType>
bool LinkedBag<ItemType>::removeSecondNode340()
{
	   Node<ItemType>* nodeToDeletePtr = headPtr->getNext();
   	 return remove(nodeToDeletePtr->getItem());		// remove the second item
}

//  addEnd340()
template<typename ItemType>
bool LinkedBag<ItemType>::addEnd340(const ItemType& newEntry)
{
	   Node<ItemType> *curPtr = headPtr;		// start from the head

	     while (curPtr->getNext() != nullptr)
       {
		      curPtr = curPtr->getNext();      //use while loop to find the last node
	     }

 	 Node<ItemType> *newNodePtr = new Node<ItemType>();       //create a new node
	 newNodePtr->setItem(newEntry);
	 curPtr->setNext(newNodePtr);               //insert to the end
	 itemCount++;
	 return true;
}

//  getCurrentSize340Iterative()
template<typename ItemType>
int LinkedBag<ItemType>::getCurrentSize340Iterative() const
{
	int count=0;
	Node<ItemType> *curPtr = headPtr;

	   while (curPtr!= nullptr)
     {
		     curPtr = curPtr->getNext();			// move to the next node
         count ++;                       //count until curPtr= headPtr
	   }
	return count;
}


//  getCurrentSize340Recursive()
template<typename ItemType>
int LinkedBag<ItemType>::getCurrentSize340Recursive() const
{
   static Node<ItemType> *curPtr = headPtr;

   if (curPtr == nullptr)
   {
        curPtr = headPtr;
        return 0;
    }
    else
    {
      curPtr = curPtr->getNext();
      return (getCurrentSize340RecursiveHelper(curPtr) );   //to function getCurrentSize340RecursiveHelper()
    }

}

// getCurrentSize340RecursiveHelper()
template<typename ItemType>
int LinkedBag<ItemType>::getCurrentSize340RecursiveHelper(Node<ItemType>*) const
{
 Node<ItemType> *curPtr = headPtr;
   int count = 0;
   if (curPtr == nullptr)
   {
        curPtr = headPtr;
        return 0;
    }
    else
    {
        curPtr = curPtr->getNext();
        count++;
        return (count + getCurrentSize340Recursive() ); // back to getCurrentSize340Recursive()
    }
}


//  getCurrentSize340RecursiveNoHelper()
template<typename ItemType>
int LinkedBag<ItemType>::getCurrentSize340RecursiveNoHelper() const
{
   static Node<ItemType>* curPtr = headPtr;
    int count = 0;

    if (curPtr == nullptr)
    {
        curPtr = headPtr;
        return 0;
    }
    else
    {
        curPtr = curPtr->getNext();
        count++;
        return (count + getCurrentSize340RecursiveNoHelper() );
    }

}



//  getFrequencyOf340Recursive()
template<typename ItemType>
int LinkedBag<ItemType>::getFrequencyOf340Recursive(const ItemType& anEntry) const
{
	 static Node<ItemType> *curPtr = headPtr;

    if (curPtr == nullptr)
    {
        curPtr = headPtr;
        return 0;
    }
    else
      return (getFrequencyOf340RecursiveHelper(curPtr,anEntry) );

}

//  getFrequencyOf340RecursiveHelper()
template<typename ItemType>
int LinkedBag<ItemType>::getFrequencyOf340RecursiveHelper(Node<ItemType>*, const ItemType& anEntry) const
{
   static Node<ItemType> *curPtr = headPtr;
   int count = 0;

    if (curPtr == nullptr)
    {
        curPtr = headPtr;
        return 0;
    }
    else if (curPtr->getItem() == anEntry)
    {
        curPtr = curPtr->getNext();
        count++;
        return (count + getFrequencyOf340Recursive(anEntry) );
    }
    else
    {
        curPtr = curPtr->getNext();
        return (count + getFrequencyOf340Recursive(anEntry));
    }

}

//   getFrequencyOf340RecursiveNoHelper()
template<typename ItemType>
int LinkedBag<ItemType>::getFrequencyOf340RecursiveNoHelper(const ItemType& anEntry) const
{
   static Node<ItemType>* curPtr = headPtr;
    int count = 0;

    if (curPtr == nullptr)
    {
        curPtr = headPtr;
        return 0;
    }
    else if (curPtr->getItem() == anEntry)
    {
        curPtr = curPtr->getNext();
        count++;
        return (count + getFrequencyOf340RecursiveNoHelper(anEntry) );
    }
    else
    {
        curPtr = curPtr->getNext();
        return (count + getFrequencyOf340RecursiveNoHelper(anEntry));
    }


}



//#8  removeRandom340()
/*template<typename ItemType>
ItemType LinkedBag<ItemType>::removeRandom340()
{

	int random_num{};
	int size = getCurrentSize340Iterative();	// number of random numbers to generate
	int min{ 1 };								// lower bound (inclusive)
	int max = size;								// upper bound (inclusive)
	ItemType item{};

	srand(time(nullptr));						// seed the random number

	   for (int i{ 1 }; i <= max; i++)
     {
	    	random_num = rand() % max + min;		// generate a random number [min, max]

	   }

	Node<ItemType>* temp1 = headPtr;		// start from the head
	int position = random_num;

	   for (int i{ 0 }; i < (position - 2); i++)
     {	// traverse through the node
			temp1 = temp1->getNext();			// temp1 points to (n-1)th Node
		 }
		Node<ItemType>* temp2 = temp1->getNext();	// nth Node
		item = temp2->getItem();
		remove(item);
		return item;
} // end removeRandom340()*/

//removeRandom340 is not working, to make the whole program work, have to hide it
/*
template<typename ItemType>
ItemType LinkedBag<ItemType>::removeRandom340()
{

   Node<ItemType>* curPtr = headPtr;
  if(curPtr == nullptr )
     return 0;

     srand(time(NULL));

     int n;
     for (n=2; curPtr!=NULL; n++)
     {
       if (rand()%n == 0)

       curPtr=curPtr->getNext();
     }
     	Node<ItemType>* node = curPtr->getNext();

     remove(node->getNext());
}
*/