如题。加法已经搞定，希望有哪位帮我改改，加个减法。谢谢。
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct polynode
{
int coef; //多项式的系数
int exp; //指数
struct polynode *next;
}node;

node *create() //用尾插法建立一元多项式的链表
{
node *h,*r,*s;
int c,e;
h=(node*)malloc(sizeof(node));
r=h;
printf("coef:");
scanf("%d",&c);
printf("exp: ");
scanf("%d",&e);
while(c!=0) //输入系数为0时，多项式的输入结束
{
s=(node*)malloc(sizeof(node));
s->coef=c;
s->exp=e;
r->next=s;
r=s;
printf("coef:");
scanf("%d",&c);
printf("exp: ");
scanf("%d",&e);
}
r->next=NULL;
return(h);
}

void print(node *p) //输出函数，打印出一元多项式
{
while(p->next!=NULL)
{
p=p->next;
printf(" %d*x^%d",p->coef,p->exp);

}
}

void polyadd(node *ha, node *hb)//一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式ha中，并将多项式hb删除
{
node *p,*q,*pre,*temp;
int sum;
p=ha->next;
q=hb->next;
pre=ha;
while(p!=NULL&&q!=NULL)
{
if(p->exp<q->exp)
{
pre->next=p;
pre=pre->next;
p=p->next;
}
else if(p->exp==q->exp)
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
temp=q;q=q->next;free(temp);
}
else //如果系数和为零，则删除结点p与q，并将指针指向下一个结点
{
temp=p->next;free(p);p=temp;
temp=q->next;free(q);q=temp;
}
}
else
{
pre->next=q;
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) //将多项式A中剩余的结点加入到和多项式中
pre->next=p;
else
pre->next=q;
}

void multipoly(node *ha,node *hb)
{ node *p,*q,*n,*m;
p=ha->next;
n=(node*)malloc(sizeof(node));
n->next=NULL;
while(p!=NULL)
{ m=(node*)malloc(sizeof(node));
for(q=hb->next;q;q=q->next)
{ m->coef=p->coef*q->coef;
m->exp=p->exp+q->exp;
m->next=NULL;
}
p=p->next;
polyadd(n,m);
}
print(n);
}


void main()
{
node *ha,*hb;
printf("请输入多项式ha的系数与指数:\n");
ha=create();
print(ha);
printf("\n");
printf("请输入多项式hb的系数与指数:\n");
hb=create();
print(hb);
printf("\n");
printf("多项式的和是:\n");
polyadd(ha,hb);
print(ha);
printf("\n");
multipoly(ha,hb);
}

其实减法的实现并不是很难，这是我写的多项式类，里面重载了+和*运算符，
分别实现了加和乘的功能，供你参考，这个类你可以直接调用，没有调用
其他的数据结构了.

#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H

#include<iostream.h>
#include<cmath>
#include<stdlib.h>

//////////////////////////////////////////////////////
//多项式每项结点的声明
//////////////////////////////////////////////////////
struct Term
{
    //每项的系数
    float coef;
    //每项的指数
    int exp;
    //下个结点的指针
    Term* link;

    //构造函数
    Term(float c,int e,Term* next=NULL)
    {
        coef=c;exp=e;link=next;
    }
    //在当前结点的后面插入一结点
    Term* InsertAfter(float c,int e);
    //重载<<运算符输出结点内容
    friend ostream& operator<<(ostream& os,const Term&);
};
//////////////////////////////////////////结点声明结束

//////////////////////////////////////////////////////
//多项式类的声明(带附加头结点)
//////////////////////////////////////////////////////
class Polynomial
{
public:
    //构造函数，建立一个新的链表
    Polynomial()
    {
        //构造一个新的空结点，即一个附加头结点
        //系数为0，指数为-1，指针默认为NULL
        first=new Term(0,-1);
    };
    
    //复制构造函数
    Polynomial(Polynomial& r);

    //得到多项式的最大阶数
    int maxOrder();

    //在当前多项式的最后追加一项
    void Appendix(float c,int e);
    //取得多项式链表的表头结点的指针
    Term* getHead()const{return first;};
    //计算多项式在x处的值
    double Calc(double);
private:
    //结点
    Term* first;
    //重载<<运算符输出多项式
    friend ostream& operator<<(ostream&,const Polynomial&);
    //重载>>输入运算符输入多项式
    friend ostream& operator>>(istream&,const Polynomial&);
    //重载+运算符进行多项式的相加
    friend Polynomial operator+(Polynomial&,Polynomial&);
    //重载*运算符进行多项式的相乘
    friend Polynomial operator*(Polynomial&,Polynomial&);
    //重载*运算符进行多项式相乘的另一种算法
    //friend Polynomial operator*(Polynomial&,Polynomial&);
};
////////////////////////////////////////////多项式类的

//////////////////////////////////////////////////////
//Term::InsertAfter()函数 在当前结点后插入一项
//////////////////////////////////////////////////////
Term* Term::InsertAfter(float c,int e)
{
    //在当前由this指针指示的项的后面插入一个新项

    //创建一个新结点
    Term* newTerm=new Term(c,e,link);
    //自动进行连接
    link=newTerm;

    //返回新插入的结点的指针
    return link;
};
///////////////////////////Term::InsertAfter()函数结束

//////////////////////////////////////////////////////
//Term结构的重载<<运算符输出结点内容
//////////////////////////////////////////////////////
ostream& operator<<(ostream& os,Term& x)
{
    //输出多项式的一项

    //如果系数为0,则什么也不输出
    if(x.coef==0.0)
        return os;

    //显示每项的系数
    os<<x.coef;

    //显示指数
    switch(x.exp)
    {
        //指数为0的情况
        case 0:
            break;

        //指数为1的情况
        case 1:
            os<<"X";
            break;

        //其他情况
        default:
            os<<"X^"<<x.exp;
            break;
    }
    return os;
};
//////////////////////////////////////////////重载结束

//////////////////////////////////////////////////////
//Polynomial类的复制构造函数
//////////////////////////////////////////////////////
Polynomial::Polynomial(Polynomial& R)
{
    //为当前链表添加一个附加头结点
    first=new Term(0,-1,NULL);

    //游标指针
    Term* dest=first;
    Term* src=R.getHead()->link;

    //指向新创建的结点
    Term* newTerm;
    //用于存放每个结点的系数和指数
    float c;
    int e;
    
    //逐个结点复制
    while(src!=NULL)
    {
        //取下对应结点的内容
        c=src->coef;
        e=src->exp;

        //用新内容创建一个新结点
        newTerm=new Term(c,e);

        //把新结点挂在当前的多项式链表中
        dest->link=newTerm;

        //目的指针往后推进一格
        dest=dest->link;
        //源指针往后推进一格
        src=src->link;
    };
};
////////////////////////////////Polynomial复制构造结束

//////////////////////////////////////////////////////
//Polynomial类的maxOrder()函数
//////////////////////////////////////////////////////
int Polynomial::maxOrder()
{
    //得到多项式的最大阶数
    //多项式都是按照指数升序来排列每项的

    //游标指针
    Term* ptr=first;
    
    //如果多项式为空
    if(ptr->link==NULL)
    {
        cout<<"该多项式为空";
        return -1;
    }
    while(ptr->link!=NULL)
    {
        //指针往后推进直到最后一格
        ptr=ptr->link;
    }

    return ptr->exp;
};
////////////////////////////////////maxOrder()函数结束

//////////////////////////////////////////////////////
//Appendix()函数 在当前多项式的最后追加一项
//////////////////////////////////////////////////////
void Polynomial::Appendix(float c,int e)
{
    //尾部指针
    Term* rear=first;
    //使指针rear指向多项式的最后一项
    while(rear->link!=NULL)
    {
        //指针向后推进一格
        rear=rear->link;
    };
    
    //以参数列表给定的系数和指数，新建一个结点
    //rear仍然指向最后的结点
    rear=rear->InsertAfter(c,e);
};

////////////////////////////////////Appendix()函数结束

//////////////////////////////////////////////////////
//友元重载<<运算符来显示Polynomial多项式的内容
//////////////////////////////////////////////////////
ostream& operator<<(ostream& os,Polynomial& x)
{
    //结点游标指针
    Term* ptr=x.getHead()->link;
    //如果多项式为空
    if(ptr==NULL)
    {
        cout<<"链表为空!"<<endl;
        return os;
    };

    //如果链表不空，则连续输出多项式链表的每一项
    cout<<"本多项式为:";
    while(ptr!=NULL)
    {
        //如果系数是正数，就在前面现实+号
        if(ptr->coef>=0.0)
        {
            cout<<"+";
        }
        cout<<*ptr;

        //指针往后推进一格
        ptr=ptr->link;
    };
    return os;
};
//////////////////////////////////////////////重载结束

//////////////////////////////////////////////////////
//友元重载>>运算符来输入一个多项式i
//////////////////////////////////////////////////////
istream& operator>>(istream& is,Polynomial& x)
{
    //键盘输入每一项，形成一个新结点插入到多项式的尾部

    //指向插入的位置的前一个位置
    Term* Rear=x.getHead();
    //存放输入的系数和指数
    float c;
    int e;

    //逐个输入每项的内容
    while(1)
    {
        cout<<"请输入多项式的每一项(系数，指数),如果指数小于0则结束输入:"<<endl;
        is>>c>>e;

        //如果指数<0则退出循环
        if(e<0)
            break;

        //把输入的系数和指数形成一个新结点插入到尾部
        Rear=Rear->InsertAfter(c,e);
    };

    return is;
};
//////////////////////////////////////////////重载结束

//////////////////////////////////////////////////////
//友元重载多项式+运算符
//////////////////////////////////////////////////////
Polynomial operator+(Polynomial& A,Polynomial& B)
{
    //定义游标指针分别指向A,B,C三个链表
    Term* pa;Term* pb;Term* pc;Term* p;
    float temp;

    //A,B的游标指针
    pa=A.getHead()->link;
    pb=B.getHead()->link;
    

    //新建一个空的结果链表，已经含有了一个附加头结点
    Polynomial C;
    pc=C.getHead();

    //多项式相加的过程
    while(pa!=NULL && pb!=NULL)
    {
        //如果指数相等
        if(pa->exp==pb->exp)
        {
            //系数相加
            temp=pa->coef+pb->coef;
            //如果系数不为0,就加入C多项式
            if(fabs(temp)>0.001)
                //加入多项式
                pc=pc->InsertAfter(temp,pa->exp);
            //指针向后推进
            pa=pa->link;
            pb=pb->link;
        }
        //如果指数A中的小于B中的
        else if(pa->exp<pb->exp)
        {
            pc=pc->InsertAfter(pa->coef,pa->exp);
            pa=pa->link;
        }
        //如果指数B中的小于A中的
        else
        {
            pc=pc->InsertAfter(pb->coef,pb->exp);
            pb=pb->link;
        }
    }

    //处理A或者B中剩余的结点
    if(pa!=NULL)
        p=pa;
    else
        p=pb;

    //把剩余的结点全部挂入结点多项式
    while(p!=NULL)
    {
        pc=pc->InsertAfter(p->coef,p->exp);
        p=p->link;
    }

    return C;
};
//////////////////////////////////////////////重载结束

//////////////////////////////////////////////////////
//友元重载*运算符进行多项式的相乘
//////////////////////////////////////////////////////
Polynomial operator*(Polynomial& A,Polynomial& B)
{
    //指向A,B的游标指针
    Term* pa;
    Term* pb;
    Term* pc;
    pa=A.getHead()->link;
    pb=B.getHead()->link;

    //指向结果指针C
    //定义一个结果多项式对象C
    Polynomial C;
    //C的游标指针
    pc=C.getHead()->link;

    //系数和指数
    float c;
    int e;

    while(pa!=NULL)
    {
        while(pb!=NULL)
        {
            //计算单个项积
            c=pa->coef*pb->coef;
            e=pa->exp+pb->exp;
            //搜索结果多项式中是否有指数相同的项
            while(pc!=NULL)
            {
                if(e==pc->exp)
                {
                    //累加多项式系数
                    pc->coef+=c;
                    break;
                }
                //指针往后推进一格
                pc=pc->link;
            };
            //没有找到就新加入到结果多项式内
            if(pc==NULL)
                C.Appendix(c,e);
            //结果多项式的游标指针复位
            pc=C.getHead();
            //B多项式
            pb=pb->link;
        };
        //A多项式指针向后推进一格
        pa=pa->link;
        //B多项式的游标指针复位
        pb=B.getHead()->link;
    }
    //返回结果多项式
    return C;
};
//////////////////////////////////////////////重载结束

[[it] 本帖最后由 geninsf009 于 2008-9-24 18:51 编辑 [/it]]

先借再减。

好帖

给你一个好看一点的！
/**********************************************/
#include <stdio.h>
#include <stdlib.h>
/***************链表实现的头文件***************/
typedef struct node
{
    int zhishu;
    int xishu;
    struct node *next;
}linknode;
typedef linknode *linklist;
/**********************************************/
/*  函数功能：      创建链表
    函数入口参数：  head   空链表的头结点
    函数返回值：    已经建好的链表的头结点
*/
linklist creat_list(linklist head)
{
    linklist x;
    linklist p;
    head=(linklist)malloc(sizeof(linknode));/*为头结点申请空间*/

        head->next=NULL;
        head->zhishu=0;
        head->xishu=0;  /*头结点全部信息置空 */
        p=head;      /*指针指向头结点 */

        while(1)
        {
            x=(linklist)malloc(sizeof(linknode));
            printf("\n Input xi shu and zhi shu:");
            scanf("%d %d",&(x->xishu),&(x->zhishu)); /*输入系数与指数，且系数与指数之间一空格键隔开 */
            if(x->xishu==0)
            {                                        /*系数与指数均可为负数*/
                printf(" ******* First list is ok!*******\n\n");
                break;  /*当系数为0时输入完成，退出循环*/
            }
            x->next=NULL; /*链接数据*/
            p->next=x;
            p=x;
        }
            


    return head;   /*返回头结点*/
}
/**********************************************/
/*函数功能：    打印出链表各节点的值
  函数入口参数：链表的头结点
  函数返回值：  无
 */
 void print_list(linklist head)
 {
    linklist p;
    p=head->next;
    printf("                      ");
    while(p!=NULL)
    {
        printf("(%d)X^%d",p->xishu,p->zhishu);
        if(p->next!=NULL)
            printf("+");
        p=p->next;
    }
   printf("\n");
 }
 /*********************************************/
 /*函数功能：       释放函数所占空间
   函数入口参数：   要释放链表的头结点
   函数返回值：     无?
  */
 void free_list(linklist head)
 {
    linklist p;
    while(head!=NULL)
    {
        p=head;
        head=head->next;
        free(p);
    }
 }
/**********************************************/
/*函数功能：实现两个多项式的相加
  函数入口参数：待相加的两个多项式所在链表的头结点
  函数返回值:   两多项式之和的链表的头结点
*/
linklist jiafa(linklist head1,linklist head2)
{
    linklist p1,p2,s;
    linklist p3,head3;
    head3=(linklist)malloc(sizeof(linknode));
    p3=head3;
    p1=head1->next;
    p2=head2->next;

    while(p1 && p2)
    {
        s=(linklist)malloc(sizeof(linknode));
        if(p1->zhishu>p2->zhishu)
        {

           s->zhishu=p1->zhishu;
           s->xishu=p1->xishu;
           p1=p1->next;
        }
        else if(p1->zhishu==p2->zhishu)
        {
            s->zhishu=p1->zhishu;
            s->xishu=p1->xishu+p2->xishu;
            p1=p1->next;
            p2=p2->next;
        }
        else
        {
           s->zhishu=p2->zhishu;
           s->xishu=p2->xishu;
           p2=p2->next;
        }
        p3->next=s;
        p3=s;

    }
    p3->next=NULL;        /*处理尾部*/
    if(p1)
        p3->next=p1;
    if(p2)
        p3->next=p2;

    return  head3;
}
/*****************************************************/
linklist jianfa(linklist head1,linklist head2)
{
    linklist p2;
    p2=head2->next;
    while(p2)
    {
        p2->xishu=(-1)*p2->xishu;
        p2=p2->next;
    }
    return jiafa(head1,head2);
}
/***********************************************/
void main()
{
    int choose;
    linklist  head1,head2,head3;
    head1=NULL;
    head2=NULL;
    head3=NULL;

      /*表头提示*/

    printf("*******************************************\n");
    printf("The xishu and zhishu are integer type!\n"); /*指数和系数都为整数类型*/
    printf("The linklist input end by xishu == 0!\n"); /* 链表输入时，当系数为0时输入结束 */
    printf("The zhishu of polynomial is form high to low!\n"); /*程序输出时指数由高到低排列 */
    printf("*******************************************\n");

    while(1)
    {
        printf("\n\n*******************************************\n");
        printf("1.jiafa!\n");
        printf("2.jianfa!\n");
        printf("0.Exit the system!\n");
        printf("Please choose:");
        scanf("%d",&choose);

        if(choose!=0&&(choose==1||choose==2))
        {
            head1=creat_list(head1); /*创建链表*/
            head2=creat_list(head2);

            if(head1!=NULL && head2!=NULL) /*运行的条件是两链表都不为空*/
            {
                 printf("The first polynomial:\n");
                 print_list(head1);   /*输出第一个链表*/
                 printf("The second polymial:\n");
                 print_list(head2);     /*输出第二个链表 */
                 printf("The result is:\n");

                 switch(choose)
                 {
                    case 1:
                        head3=jiafa(head1,head2);
                        break;
                    case 2:
                        head3=jianfa(head1,head2);
                        break;
                    default:
                        break;
                 }

                print_list(head3);          /* 输出结果 */
                printf("That is over!\n");
               
                free_list(head1); /* 释放掉空间 */
                free_list(head2);
                free_list(head3);

             }

        if(head1==NULL && head2==NULL)      /*当两个链表为空时，显示为空 */
            printf("The list is empty!!\n");
        }
        if(choose==0)
            break;
     }
    getch();
}

顶五楼的！~~