多项式的运算

上原题：

设计程序，实现对多项式的加，减，乘，除，微分和积分的运算。考虑分别用顺序分配的线性表和链接分配的线性表表示多项式的实现。估计各项运算的算法复杂性。

本来钱老师只要求用后一种的，结果我没看到，两种都编了，麻烦死。

别的都还好说，这多项式的除法真烦人。娘的，老子火很大。链接表的除法实在太烦了，我就直接把链表转化成数组然后调用数组的除法函数，这样只要一次遍历表就OK，感觉效率还蛮高的。就这么地吧。

数组线性表：

  1#ifndef LIST
  2#define LIST
  3using namespace std;
  4#define N 1000
  5
  6class ListType
  7{
  8    friend ListType ListPlus(ListType L1,ListType L2);         
  9    friend ListType ListMinus(ListType L1,ListType L2);
 10    friend ListType ListMulti(ListType L1,ListType L2);
 11    friend ListType ListDevide(ListType L1,ListType L2);
 12    friend ListType ListDs(ListType L);
 13    friend ListType ListJf(ListType L);
 14    friend bool operator==(ListType,ListType);
 15    public:
 16            int Limit;
 17            int Length;
 18            ListType();
 19            //~ListType();
 20            String Print();
 21            void Insert(double Item,int Position);
 22            void Delete(int Position);
 23            void Clear();
 24
 25            double Data[N];
 26};
 27void ListType::Insert(double Item,int Position)
 28{
 29    Data[Position] += Item;
 30}
 31void ListType::Delete(int Position)
 32{
 33    Data[Position] = 0;
 34}
 35void ListType::Clear()
 36{
 37    for(int i = 0; i < Limit;i++)
 38    {
 39        Data[i]= 0;
 40    }
 41}
 42String ListType::Print()
 43{
 44    String ss;
 45    String pos;
 46    String xs;
 47    String fh;
 48    for(int i = 0;i <= Length ; i++)
 49    {
 50      if(Data[i]!= 0)
 51        {
 52            if(Data[i]>0)fh = "+";
 53            else fh = "";
 54            pos = i;xs = Data[i];
 55            ss = ss + fh +xs+"x^"+pos;
 56        }
 57    }
 58    return ss;
 59    
 60}
 61ListType::ListType()         //initial
 62{
 63    Length = 0;
 64    Limit = N;
 65    for(int i =0;i< Limit; i++)
 66    {
 67        Data[i] = 0;
 68    }
 69}
 70
 71ListType ListPlus(ListType L1,ListType L2)
 72{
 73    ListType L3;
 74    int max;
 75    if(L1.Length > L2.Length)max = L1.Length;
 76    else max = L2.Length;
 77    L3.Length = max;
 78    for(int i = 0; i <= max; i++)
 79    {
 80         L3.Data[i] = L1.Data[i]+ L2.Data[i];
 81    }
 82    return L3;
 83}
 84ListType ListMinus(ListType L1,ListType L2)
 85{
 86
 87    ListType L3;
 88    int max;
 89    if(L1.Length > L2.Length)max = L1.Length;
 90    else max = L2.Length;
 91    L3.Length = max;
 92    for(int i = 0; i <= max; i++)
 93    {
 94         L3.Data[i] = L1.Data[i] - L2.Data[i];
 95    }
 96    while(L3.Length != 0 && L3.Data[L3.Length] == 0)
 97    {
 98         L3.Length--;
 99    }
    return L3;
}
ListType ListMulti(ListType L1,ListType L2)
{
    ListType L3;
    int max;
    max = L1.Length + L2.Length;
    L3.Length = max;
    for(int i =0;i <= L1.Length; i++)
    {
        for(int j = 0;j <= L2.Length ; j++)
        {
            L3.Data[i+j] += L1.Data[i]*L2.Data[j];
        }
    }
    return L3;
}
ListType ListDevide(ListType L1,ListType L2)
{
    ListType L3;
    ListType L4;
    while(1)
    {
        if(L1.Length >= L2.Length)
        {
             L4.Clear();
             L4.Length = L1.Length - L2.Length;

             L4.Data[L4.Length] = L1.Data[L1.Length]/L2.Data[L2.Length];

             L3 = ListPlus(L3,L4);
             L4 = ListMulti(L4,L2);

             L1 = ListMinus(L1,L4);

             if(L1.Length == 0)break;
        }
        else
        {
            ShowMessage("无法进行除法运算！");
            break;
        }
    }
    return L3;
}
ListType ListDs(ListType L)
{

    ListType L3;
    for(int i =0 ;i < L.Length;i++)
    {
        L3.Data[i]= L.Data[i+1]*(i+1);
    }
    L3.Length = L.Length-1;
    return L3;
}
ListType ListJf(ListType L)
{
    ListType L3;
    for(int i =0 ;i <= L.Length; i++)
    {
        L3.Data[i+1]= L.Data[i]/(i+1);
    }
    L3.Length = L.Length+1;
    return L3;
}
bool operator==(ListType L1,ListType L2)
{
    if(L1.Length != L2.Length)return false;
    if(L1.Length == L2.Length)
    {
        for(int i =0 ;i <= L1.Length;i++)
        {
             if(L1.Data[i]!= L2.Data[i])return false;
        }
    }
    return true;
}

#endif

链接表

  1#ifndef CHAIN
  2#define CHAIN
  3#include "List.h"
  4struct Node
  5{
  6    double Data;
  7    int pos;
  8    Node *Next;
  9    Node *Previous;
 10};
 11
 12class Chain
 13{
 14    friend Chain ChainPlus(Chain C1,Chain C2);
 15    friend Chain ChainMinus(Chain C1,Chain C2);
 16    friend Chain ChainMulti(Chain C1,Chain C2);
 17    friend Chain ChainDevide(Chain C1,Chain C2);
 18    friend Chain ChainDs(Chain C);
 19    friend Chain ChainJf(Chain C);
 20    friend bool operator==(Chain,Chain);
 21    public:
 22            Chain();
 23            //~Chain();
 24            void InsertBack(double Item,int pos ,Node *Position);
 25            void InsertFront(double Item,int pos,Node *Position);
 26            void DeleteNode(Node *Position);
 27            void PushBack(double Item,int Pos);
 28            void Clear();
 29            Node *Search(int order);
 30            String Print();
 31            Chain Mod();
 32            ListType Mody();
 33    private:
 34            Node *Head;
 35
 36};
 37Chain::Chain()
 38{
 39    Head = new Node;
 40    Head->Next = NULL;
 41    Head->Data = 0;
 42    Head->pos = 0;
 43    Head->Previous = NULL;
 44
 45}
 46void Chain::InsertBack(double Item,int postemp,Node *Position)
 47{
 48    Node *p;
 49    if(Position == NULL)ShowMessage("No pointed Node");
 50    else
 51    {
 52        p = new Node;
 53        p->Data = Item;
 54        p->pos = postemp;
 55        p->Previous = Position;
 56        p->Next = Position->Next;
 57        if(Position->Next != NULL)Position->Next->Previous = p;
 58        Position->Next = p;
 59    }
 60}
 61void Chain::InsertFront(double Item,int Pos,Node *Position)
 62{
 63    Node *p;
 64    if(Position == NULL)ShowMessage("No pointed Node");
 65    else
 66    {
 67        p = new Node;
 68        p->Data = Item;
 69        p->Previous = Position->Previous;
 70        p->Next = Position;
 71        p->Previous->Next = p;
 72        Position->Previous = p;
 73    }
 74}
 75void Chain::PushBack(double Item,int Pos)
 76{
 77     Node *p = Head;
 78     while(p->Next != NULL)p = p->Next;
 79     InsertBack(Item,Pos,p);
 80}
 81void Chain::DeleteNode(Node *Position)
 82{
 83    if(Position == Head && Position == NULL)ShowMessage("No deletable Node");
 84    else if(Head->Next == NULL)ShowMessage("No deletable Node");
 85        else
 86        {
 87            Position->Previous->Next = Position->Next;
 88            if(Position->Next != NULL)Position->Next->Previous = Position->Previous;
 89            delete Position;
 90        }
 91}
 92void Chain::Clear()
 93{
 94    Node *p = Head->Next ;Node * temp;
 95    while(p != NULL)
 96    {
 97         temp = p->Next;
 98         delete p;
 99         p =temp;
    }
    Head->Next = NULL;
}
String Chain::Print()
{
    String ss;
    String poss;
    String xs;
    String fh;
    Node * p;
    for(p = Head;    p->Next != NULL ; p = p->Next)
    {
      if(p->Data != 0)
        {
            if(p->Data>0)fh = "+";
            else fh = "";
            poss = p->pos;xs = p->Data;
            ss = ss + fh +xs+"x^"+poss;
        }
    }
          if(p->Data != 0)
        {
            if(p->Data>0)fh = "+";
            else fh = "";
            poss = p->pos;xs = p->Data;
            ss = ss + fh +xs+"x^"+poss;
        }
    return ss;
}
Chain Chain::Mod()
{
    Node *p;
    p = Head;
    Chain C3;

    double ss[1000]; int Length = 0;
    for(int i =0;i<1000;i++)ss[i]=0;
    while(p != NULL)
    {
        ss[p->pos] += p->Data;
        if(p->pos >Length)Length = p->pos;
        p = p->Next;
    }
    for(int i =0;i <= Length; i ++)
    {
        if(ss[i]!=0){C3.PushBack(ss[i],i);}
    }
    return C3;
}
ListType Chain::Mody()
{
    ListType L;L.Length = 0;
    Node *p; p = Head;
    while(p != NULL)
    {
        if(p->pos >L.Length)L.Length = p->pos;
        L.Data[p->pos] += p->Data;
        p = p->Next;
    }
    return L;
}
Chain ChainPlus(Chain C1,Chain C2)
{
    Chain C3;
    Node *ptr;
    ptr = C1.Head;

    while(ptr->Next != NULL)ptr = ptr->Next;
    ptr->Next = C2.Head;
    C2.Head->Previous = ptr;

    C3 = C1.Mod();
    return C3;
}
Chain ChainMinus(Chain C1,Chain C2)
{
    Chain C3;
    Node *ptr;
    ptr = C1.Head;
    Node *re;
    re = C2.Head;
    while(re->Next != NULL)
    {
        re->Data = 0 - re->Data ;
        re = re->Next;
    }
    re->Data = 0 - re->Data ;
    while(ptr->Next != NULL)ptr = ptr->Next;
    ptr->Next = C2.Head;
    C2.Head->Previous = ptr;
    C3 = C1.Mod();
    return C3;
}
Chain ChainMulti(Chain C1,Chain C2)
{
    Chain C3;
    double dp;
    int ip;
    Node *ptr1;Node *ptr2;
    for(ptr1 = C1.Head;ptr1    != NULL;ptr1 = ptr1->Next )
    {
        for(ptr2 = C2.Head;ptr2 != NULL; ptr2 = ptr2->Next)
        {
              dp = (ptr1->Data)*(ptr2->Data);
              ip =  ptr1->pos + ptr2->pos;
              C3.PushBack(dp,ip);
        }
    }
    C3= C3.Mod();
    return C3;
}
Chain ChainDevide(Chain C1,Chain C2)
{
    ListType temp;
    temp = ListDevide(C1.Mody(),C2.Mody());
    Chain C3;
    for(int i = 0; i <= temp.Length;i++)
    {
        if(temp.Data[i] != 0)C3.PushBack(temp.Data[i],i);
    }
    return C3;
}
Chain ChainDs(Chain C)
{
    Node *p = C.Head;
    while(p != NULL)
    {
        p->Data = (p->Data)*(p->pos);
        p->pos--;
        p = p->Next;
    }
    C = C.Mod();
    return C;
}
Chain ChainJf(Chain C)
{
    Node *p = C.Head;
    while(p != NULL)
    {
        p->pos += 1;
        p->Data = (p->Data)/(p->pos);
        p=p->Next;
    }
    C = C.Mod();
    return C;
}

bool operator==(Chain C1,Chain C2)
{
    Node *p1;Node *p2;
    p1 = C1.Head;p2 = C2.Head;
    while(p1 != NULL && p2 != NULL)
    {
        if(p1->Next == NULL &&p2->Next != NULL)return false;
        else if(p2->Next == NULL &&p1->Next != NULL)return false;
        else if(p1->Data != p2->Data)return false;
        else if(p1->pos != p2->pos)return false;

        p1 = p1->Next;
        p2 = p2->Next;
    }
    return true;

}

#endif