Sorting polynomial terms based on degrees - c++

Question

I have this code which is about polynomials multiplication.
I meet no error, just what I want is to sort the terms based on degrees (from lower degree to higher).
If I add condition in operator* in //commented part, it will be printed too many of times. I would like to know if I can use m_Polynomial.sort()? If yes how? If not, what other methods can I use?
As it is both for printing polynomials and their multiplication result it would be nice if it could be added in print function.
Also if it is possible to change the printing style of Polynomials to desired format (to add coefficients of same degree terms)
Minimal code:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <vector>
using namespace std;
typedef struct Node
{
double cof; // coefficient
int deg; // degree
} Node;
class CPolynomial
{
public:
CPolynomial();
CPolynomial(const string& file);
~CPolynomial();
CPolynomial operator*(const CPolynomial &right);
CPolynomial& operator=(const CPolynomial &right);
void Print() const;
private:
void ReadFromFile(string file);
private:
list<Node> m_Polynomial;
};
int main()
{
CPolynomial p1("P3.txt");
CPolynomial p2("P4.txt");
CPolynomial p3;
p1.Print();
p2.Print();
p3 = p1*p2;
p3.Print();
system("pause");
return 0;
}
CPolynomial::CPolynomial()
{
Node term;
term.cof = 0;
term.deg = 0;
m_Polynomial.push_back(term);
}
CPolynomial::~CPolynomial()
{
m_Polynomial.clear();
}
CPolynomial::CPolynomial(const string& file)
{
ReadFromFile(file);
}
CPolynomial CPolynomial:: operator*(const CPolynomial &right)
{
CPolynomial result;
result.m_Polynomial = m_Polynomial;
for (list<Node>::iterator itr = result.m_Polynomial.begin(); itr != result.m_Polynomial.end(); ++itr)
{
itr->cof = 0;
itr->deg = 0;
}
Node term;
Node termR;
Node temp;
for (list<Node>::const_iterator it = m_Polynomial.begin(); it != m_Polynomial.end(); ++it)
{
for (list<Node>::const_iterator itR = right.m_Polynomial.begin(); itR != right.m_Polynomial.end(); ++itR)
{
term = *it;
termR = *itR;
temp.cof = termR.cof* term.cof;
temp.deg = termR.deg + term.deg;
for (list<Node>::iterator itr = result.m_Polynomial.begin(); itr != result.m_Polynomial.end(); ++itr)
{
if (temp.deg == itr->deg)
{
temp.cof += itr->cof;
itr->cof = 0;
}
// if(temp.deg < it->deg)
//result.m_Polynomial.insert(it, temp);
}
result.m_Polynomial.push_back(temp);
}
}
return result;
}
CPolynomial& CPolynomial:: operator=(const CPolynomial &right)
{
this->m_Polynomial = right.m_Polynomial;
return *this;
}
void CPolynomial::Print() const
{
list<Node>::const_iterator it;
for (it = m_Polynomial.begin(); it != m_Polynomial.end(); it++)
{
if (it->cof == 0)
{
;
}
else
{
if (it->cof > 0)
{
if (it != m_Polynomial.begin()) // if 'it' is not the first term, '+' is not necessary
cout << "+";
}
cout << it->cof;
if (it->deg != 0)
cout << "x^" << it->deg;
}
}
cout << endl;
}
void CPolynomial::ReadFromFile(string file)
{
Node term;
fstream MyFile;
string p;
int num;
MyFile.open(file);
if (!MyFile.is_open())
{
cerr << "Unable to open input file" << endl;
exit(EXIT_FAILURE);
}
else
{
MyFile >> p >> num;
std::list<Node>::iterator it = m_Polynomial.begin();
for (int i = 0; i < num; i++)
{
MyFile >> term.deg >> term.cof;
m_Polynomial.push_back(term);
}
MyFile.close();
}
}
P1.txt
P 8
0 2
5 -3
12 5
2 6
5 7
3 -4
2 9
2 2
P4.txt
P 2
1 4
4 -3
Output
2-3^5+5x^12+6x^2+7x^5-4x^3+9x^2+2x^2 (P1)
4x^1-3x^4 (P2)
8x^1+20x^13-15x^16_12x^9-22x^4+12x^7+68x^3 (P1*P2)
desired output:
2+17x^2-4x^3+4x^5+5x^12
4x^1-3x^4
8x^1+68x^3-22x^4+12x^7_12x^9+20x^13-15x^16

Answer 1

Your operator modifies its left operand, why?
If you say p3 = p1 * p2; then it is wrong to modify p1, you should return a new object with a new value, and not alter the operands.
One solution is to provide operator*= as a member function that alters its left operand, then define operator* as a non-member function:
CPolynomial operator*(const CPolynomial& lhs, const CPolynomial& rhs)
{
CPolynomial result = lhs;
result *= rhs;
return result;
}
The bug appears to be in AddOneTerm where you do the comparisons wrong. Your loop will insert the new term at the first position where (term.deg >= it->deg) but it should be the last position where that is true.
Also you should use AddOneTerm(term) instead of m_Polynomial.push_back(term) in ReadFromFile to ensure the terms are kept in the correct order.
You also have very confusing use of iterators:
std::list<Node>::iterator next_it;
next_it = ++it;
Now both next_it and it have been incremented, so they are both the next term. Why?
I suggest something much simpler:
void CPolynomial::AddOneTerm(Node term)
{
auto it = m_Polynomial.begin();
while (it != m_Polynomial.end() && it->deg < term.deg)
{
++it;
}
if (it != m_Polynomial.end() && term.deg == it->deg)
{
it->cof += term.cof;
}
else
{
m_Polynomial.insert(it, term);
}
}
You could also define a comparison operator for Node objects:
bool operator<(const Node& l, const Node& r)
{
return l.deg < r.deg;
}
Now you can easily sort your list<Node> structure, and you can use lower_bound to find the right position in AddOneTerm:
void CPolynomial::AddOneTerm(Node term)
{
auto it = std::lower_bound(m_Polynomial.begin(), m_Polynomial.end(), term);
if (it != m_Polynomial.end() && term.deg == it->deg)
{
it->cof += term.cof;
}
else
{
m_Polynomial.insert(it, term);
}
}