数据结构和算法C++语言实现：使用链表实现稀疏多项式

1、链表的基础知识

关于链表的基础知识还有不熟悉的，请查看链表的实现（基于动态内存分配）

2、使用链表实现稀疏多项式，也是基于上述的链表来实现的。

稀疏多项式可以当作一种链表结构，所以，可以直接从上述的链表派生过来。在派生之前应该考虑清楚稀疏多项式的结构，稀疏多项式的基本单元由系数和指数构成，所以构成该类的模板需要两个参数，声明为如下的形式：

template<typename T,typename S>
class CPolynomial

由于CPolynomial是从CList继承过来的，CList的声明如下所示：

template <typename T>
class List
{
protected:
class Node
{
public:
Node *pNext;
T m_data;

Node()
{
memset(&m_data, 0, sizeof(m_data));
pNext = NULL;
}
};
//typedef Node * Link_List;
int m_Lenth;

public:
List();
List(const List &m_List);
~List();
const List&operator=(const List &m_List);

bool List_IsEmpty();
int  List_Lenth();
void List_Insert(T num);
void List_Delete(int nPos);
void List_Destroy();
void List_Clear();
void List_Display();
Node * List_GetHead() const;
bool List_FindElem(T num);
void List_Modify(T num, int nPos);

protected:

//Link_List pHead;
Node *pHead;
typedef Node* Position;
};

#endif

在构建CPolynomial时，还需要考虑到基类的模板的参数化的问题，所以，这里需要提供一个模板类，用以实例化CList,定义如下：

template<typename T,typename S>
class Item
{
public:
T coeff;
S index;

Item()
{
coeff = 0;
index = 0;
}
Item(const Item& item)
{
coeff = item.coeff;
index = item.index;
}

Item & operator = (const Item& item)
{

coeff = item.coeff;
index = item.index;

return *this;
}

bool operator == (const Item& item)
{
return coeff == item.coeff&& index == item.index;
}
};

为什么要按照上述的方法来定义呢？从如下的方面来考虑的：

1、该实例类需要和CPolynomial中的指数和系数对应

2、该实例化类的对象之间存在赋值，拷贝，判断相等的操作

到目前，构建该多项式类的基本工作已经完成了，下面需要来实际构建该类：

<pre name="code" class="cpp">template<typename T,typename S>
class CPolynomial :public List<Item<T,S>>
{
public:

CPolynomial();
CPolynomial(const CPolynomial& poly);
~CPolynomial();

//操作符重载
const CPolynomial &operator =(const CPolynomial &polyn);
//friend CPolynomial operator+(const CPolynomial &polyn);
//①friend CPolynomial operator+<>(const CPolynomial<T,S>& polynLeft,const CPolynomial<T,S> &polynRight);

template<typename T,typename S>
friend CPolynomial<T, S> operator+(const CPolynomial<T, S>&, const CPolynomial<T, S>&);

template<typename T,typename S>
friend CPolynomial<T,S> operator-(const CPolynomial<T,S>& polynLeft,const CPolynomial<T,S> &polynRight)
{
CPolynomial<T, S> polynTemp = polynLeft;
polynTemp.PolynSubstract(polynRight);

return polynTemp;
}

friend CPolynomial operator*(const CPolynomial &polyn)
{

}

void PolynInsert(const Item<T,S> & item);
void PolynRemove(const Item<T,S> & item);
bool PolynSearch(const Item<T,S> &item,int &nPos);
bool PolynSearchIndex(const S& index,Position *pos = NULL);
bool PolynModify(Position pos);
bool PolynIsEmpty();
void PolynClear();
void PolynDestroy();
void PolynPrint();

void PolynAdd(const CPolynomial &polynSecond);
void PolynSubstract(CPolynomial polynSecond);
void PolynMultiply(CPolynomial polynFirst, CPolynomial polynSecond);

public:
int m_nLenth;
List<Item<T,S>> m_List;
};

上述的多项式类至此已经构建完成，接下来便进行相关的测试：

<pre name="code" class="cpp">#include "List.h"
#include "List.cpp"
#include "Polynomial.h"
#include "Polynomial.cpp"

void main()
{
List<int> myList;
for(int i=0;i<12;i++)
{
myList.List_Insert(i);
}

myList.List_Insert(15);
cout<<"**myList:"<<myList.List_Lenth()<<endl;
myList.List_Display();

List<int> newList = myList;
cout<<"**newList:"<<newList.List_Lenth()<<endl;
newList.List_Display();

myList.List_Insert(-2);
List<int> newOpList;
newOpList = myList;
cout<<"**newOpList:"<<newOpList.List_Lenth()<<endl;
newOpList.List_Display();

for(int i=0;i<5;i++)
newOpList.List_Delete(1);
cout<<"**newOpList:"<<newOpList.List_Lenth()<<endl;
newOpList.List_Display();

newOpList.List_Destroy();

Item<double, int> item;
CPolynomial<double, int> m_Polyn;
for (int i = 1; i < 6; i++)
{
item.coeff = i*3.14;
item.index = i;
m_Polyn.PolynInsert(item);
}

m_Polyn.PolynPrint();

CPolynomial<double, int> m_PolynSecond;
for (int i = 3; i < 8; i++)
{
item.coeff = i*i;
item.index = i;
m_PolynSecond.PolynInsert(item);
}

cout << "Second:" << endl;
m_PolynSecond.PolynPrint();

m_Polyn.PolynAdd(m_PolynSecond);
cout << "Add:" << endl;
m_Polyn.PolynPrint();

CPolynomial<double, int> m_PolynThird;
m_PolynThird = m_Polyn + m_PolynSecond;
cout << "+:" << endl;
m_PolynThird.PolynPrint();

CPolynomial<double, int> m_PolynForth;
m_PolynForth = m_PolynThird - m_PolynSecond;
cout << "Forth:" << endl;
m_PolynForth.PolynPrint();
system("pause");

}

最终程序的输出如下所示：



至此，多项式的构建完成了。通过类模板和继承来实现了稀疏多项式，并且实现了操作符的重载。