C++ Polynomial::addTermToList方法代码示例

// O(n^2) factoring 
void Polynomial::factor()
{
	/*
	PRE-CONDITIONS: 
	The polynomial is of the correct format.

	POST-CONDITIONS: 
	The polynomial will combine all like terms in preparation for either output or addition.
	*/
	Polynomial newPoly;
	Term currentTerm;
	int newCoefficient;

    // Loop while there is a term left to check
	while (termList.size() > 0)
	{
		bool foundLikeTerm = false;

        // If there are no terms in the new polynomial add the first term
		if (newPoly.getNumTerms() == 0)
		{
            // If the exponent is anything but 0, add the term as is.
            if (termList.front().getExponent() != 0)
            {
                newPoly.addTermToList(termList.front());
                termList.pop_front();
            }
            else{
                // If the exponent is zero, drop the variable and add the coefficient
                newPoly.addTermToList(Term(termList.front().getCoefficient()));
                termList.pop_front();
            }
		}
		else
        {
            // Set new current term to be checked against the new polynomial
            currentTerm = termList.front();

            // If the exponent of the term is zero, drop the variable
            if (currentTerm.getExponent() == 0)
                currentTerm = Term(termList.front().getCoefficient());

            // Iterate through the new polynomial to check for matches of exponents
            // If the exponents match add the terms together, else add to the end of the new poly
			for (list<Term>::iterator iter = newPoly.termList.begin(); iter != newPoly.termList.end();)
			{
                // If the exponents match or they are both numbers with no variables, add them together
				if ((iter->getExponent() == currentTerm.getExponent()) || (iter->getHasVariable() == false && currentTerm.getHasVariable() == false))
				{
					newCoefficient = iter->getCoefficient() + currentTerm.getCoefficient();
					iter->setCoefficient(newCoefficient);
                    foundLikeTerm = true;
                    break;
                }
				else{
                    // Advance iterator if no matches are found on the current term
					iter++;
				}
			}

            // If it gets through the new poly without a match, add it to the new poly
            if(foundLikeTerm == false)
                newPoly.addTermToList(currentTerm);

            termList.pop_front();

		}
	}

    // Clear everything from old polynomial, update with the new polynomial
    termList = newPoly.termList;
}

// O(n^2 + m^2) from factor
// O(n log n) sort
// O(n * m) adding
Polynomial Polynomial::operator +(Polynomial& rhs)
{
	/*
	PRE-CONDITIONS:
	The two polynomials have been entered in the correct format.  Factoring called in-function.

	POST-CONDITIONS:
	The polynomial will combine all like terms from both of the polynomials and return the result as a new polynomial.
	*/

	Polynomial newPoly;
	bool foundLikeTerm;
	int newCoefficient;

    // factor polynomials before adding them together
    factor();
    rhs.factor();

	// begin comparing terms from each Polynomial and combining them
	for (list<Term>::iterator iter = termList.begin(); iter != termList.end(); iter++)
	{
		foundLikeTerm = false;
		// compare each term from poly1 with every term from poly2
		for (list<Term>::iterator iter2 = rhs.termList.begin(); iter2 != rhs.termList.end();)
		{
			if (iter->getHasVariable() == true && iter->getExponent() == iter2->getExponent())
			{
				// If there is a like term, add the coefficients together and add to new poly list
				foundLikeTerm = true;
				newCoefficient = iter->getCoefficient() + iter2->getCoefficient();
                // Advance iterator and delete current term
				iter2 = rhs.termList.erase(iter2);

				if (newCoefficient != 0)
					// Add combined term to new polynomial
					newPoly.addTermToList(Term(newCoefficient, iter->getExponent()));
			}
			else if (iter->getHasVariable() == false && iter2->getHasVariable() == false)
			{
				foundLikeTerm = true;
				newCoefficient = iter->getCoefficient() + iter2->getCoefficient();
                // Advance iterator and delete current term
				iter2 = rhs.termList.erase(iter2);
                // Add combined term to new polynomial if it is anything but zero.
				if (newCoefficient != 0)
					newPoly.addTermToList(Term(newCoefficient));
			}
			else{
				iter2++;
			}
		}
		// If there are no terms to be combined with, add term as it is.
		// drop stand alone zeros from the polynomial
		if (foundLikeTerm == false && iter->getCoefficient() != 0)
			newPoly.addTermToList(*iter);
	}

	// add remaining terms from poly2 that had no matching terms in poly1
	for (list<Term>::iterator iter2 = rhs.termList.begin(); iter2 != rhs.termList.end(); iter2++)
		newPoly.addTermToList(*iter2);

    // Sort (ascending order) and reverse to get it descending
    newPoly.termList.sort(greater<Term>());

	return newPoly;
}