數據結構課程設計：順序結構、動態鏈表結構下的一元多項式的加法、減法、乘法的實現

本文轉載自查看原文 2012-12-14 20:29 3677

原來做的數據結構課程設計，今天整理資料時偶然發現了，自己留着沒啥意思，共享一下吧，互相交流學習

要求

設有一元多項式Am(x)和Bn(x).

Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm

Bn(x)=B0+B1x1+B2x2+B3x3+… +Bnxn

請實現求M(x)= Am(x)+Bn(x)、M(x)= Am(x)-Bn(x)和M(x)= Am(x)×Bn(x)。

要求：

1)首先判定多項式是否稀疏

2)分別采用順序和動態存儲結構實現；

3)結果M(x)中無重復階項和無零系數項；

4)要求輸出結果的升冪和降冪兩種排列情況

算法分析：

以后再寫。

代碼實現：

#include<stdio.h>

#include<malloc.h>
#include<stdlib.h>
struct data{
     int xishu;
     int zhishu;
};
struct node{
    data dat;
    node *next;
};
int cmp( const void *a, const void *b)
{
     return ((data*)a)->zhishu-((data*)b)->zhishu;
}
void output(node *head)
{
    node *p;
    node *shengxu;
    shengxu= new node;
    shengxu->next=NULL;
    printf( " 升序排列\n ");
    p=head->next;
     while(p)
    {
         if(p->dat.xishu< 0)
            printf( " \b ");
         if(p->dat.xishu!= 0)
        {
             if(p->dat.xishu== 1)
                printf( " X^%d+ ",p->dat.zhishu);
             else if(p->dat.xishu==- 1)
                printf( " -X^%d+ ",p->dat.zhishu);
             else
                printf( " %dX^%d+ ",p->dat.xishu,p->dat.zhishu);
        }
        node *q;
        q= new node;
        q->dat.zhishu=p->dat.zhishu;
        q->dat.xishu=p->dat.xishu;
        q->next=shengxu->next;
        shengxu->next=q;
        p=p->next;
    }
    printf( " \b \n ");
    printf( " 降序排列\n ");
    p=shengxu->next;
     while(p)
    {
         if(p->dat.xishu< 0)
            printf( " \b ");
         if(p->dat.xishu!= 0)
        {
             if(p->dat.xishu== 1)
                printf( " X^%d+ ",p->dat.zhishu);
             else if(p->dat.xishu==- 1)
                printf( " -X^%d+ ",p->dat.zhishu);
             else
                printf( " %dX^%d+ ",p->dat.xishu,p->dat.zhishu);
        }
        p=p->next;
    }
    printf( " \b \n ");
}
int main()
{
     int sum1,sum2;
    data *d1,*d2;
     int zhishu_max1=- 1,zhishu_max2=- 1;
     int i,j;
     int *biaodashi1,*biaodashi2;
    node *he,*cha;
    node *head1,*head2,*tail1,*tail2;
    head1=(node *)malloc( sizeof(node));
    head2=(node *)malloc( sizeof(node));
    head1->next=NULL;
    head2->next=NULL;
    tail1=head1;
    tail2=head2;
     // 輸入第一個表達式
    printf( " 請輸入第一個多項式的項數： ");
    scanf( " %d ",&sum1);
    d1=(data*)malloc(sum1* sizeof(data));
    printf( " 請依次輸入每項多項式的系數和指數:\n ");
     for(i= 0;i<sum1;i++)
    {
        scanf( " %d%d ",&d1[i].xishu,&d1[i].zhishu);
    }
     // 輸入第二個表達式
    printf( " 請輸入第二個多項式的項數： ");
    scanf( " %d ",&sum2);
    d2=(data*)malloc(sum2* sizeof(data));
    printf( " 請依次輸入每項多項式的系數和指數:\n ");
     for(i= 0;i<sum2;i++)
    {
        scanf( " %d%d ",&d2[i].xishu,&d2[i].zhishu);
    }
     // 排序
    qsort(d1,sum1, sizeof(data),cmp);
    qsort(d2,sum2, sizeof(data),cmp);
    zhishu_max1=d1[sum1- 1].zhishu;
    zhishu_max2=d2[sum2- 1].zhishu;
     for(i= 0;i< 30;i++)
        printf( " == ");
    printf( " \n ");
     // 輸出第一個表達式
    printf( " 第一個表達式為：\n ");
     for(i= 0;i<sum1;i++)
    {
         if(d1[i].xishu!= 0)
        {
             if(d1[i].xishu== 1)
                printf( " X^%d ",d1[i].zhishu);
             else if(d1[i].xishu==- 1)
                printf( " -X^%d ",d1[i].zhishu);
             else
                printf( " %dX^%d ",d1[i].xishu,d1[i].zhishu);
        }
         if(i<sum1- 1)
            printf( " + ");
    }
    printf( " \n ");
     // 判斷是否稀疏
     if(zhishu_max1-d1[ 0].zhishu>(sum1* sizeof(node)))
    {
        printf( " 第一個表達式稀疏\n\n ");
         for(i= 0;i<sum1;i++)
        {
            node *p;
            p=(node*)malloc( sizeof(node));
            p->dat.zhishu=d1[i].zhishu;
            p->dat.xishu=d1[i].xishu;
            tail1->next=p;
            p->next=NULL;
            tail1=p;
        }
    }
     else
    {
        printf( " 第一個表達式稠密!\n\n ");
        biaodashi1=( int*)malloc(zhishu_max1* sizeof( int));
        j= 0;
         for(i= 0;i<=zhishu_max1;i++)
        {
             if(i==d1[j].zhishu){
                biaodashi1[i] =d1[j].xishu;
                j++;
            }
             else
                biaodashi1[i]= 0;
        }
    }
     // 輸出第二個表達式
    printf( " 第二個表達式為：\n ");
     for(i= 0;i<sum2;i++)
    {
         if(d2[i].xishu!= 0)
        {
             if(d2[i].xishu== 1)
                printf( " X^%d ",d2[i].zhishu);
             else if(d2[i].xishu==- 1)
                printf( " X^%d ",d2[i].zhishu);
             else
                printf( " %dX^%d ",d2[i].xishu,d2[i].zhishu);
        }
         if(i<sum2- 1)
            printf( " + ");
    }
    printf( " \n ");
     // 判斷是否稀疏
     if(zhishu_max2-d2[ 0].zhishu>(sum2* sizeof(node)))
    {
        printf( " 第一個表達式稀疏\n\n ");
         for(i= 0;i<sum2;i++)
        {
            node *p;
            p=(node*)malloc( sizeof(node));
            p->dat.zhishu=d2[i].zhishu;
            p->dat.xishu=d2[i].xishu;
            tail2->next=p;
            p->next=NULL;
            tail2=p;
        }
    }
     else
    {
        printf( " 第二個表達式稠密!\n\n ");
        biaodashi2=( int*)malloc(zhishu_max2* sizeof( int));
        j= 0;
         for(i= 0;i<=zhishu_max2;i++)
        {
             if(i==d2[j].zhishu){
                biaodashi2[i]=d2[j].xishu;
                j++;
            }
             else
                biaodashi2[i]= 0;
        }
    }
     // 求兩個多項式的和和差
    he= new node;
    cha= new node;
    he->next=NULL;
    cha->next=NULL;
    node *cha_tail,*he_tail;
    he_tail=he;
    cha_tail=cha;
     for(i= 0,j= 0;i<sum1&&j<sum2;)
    {
        node *p,*p2;
        p= new node;
        p2= new node;
         if(d1[i].zhishu<d2[j].zhishu)
        {
            p->dat.zhishu=d1[i].zhishu;
            p->dat.xishu=d1[i].xishu;
            p2->dat.zhishu=d1[i].zhishu;
            p2->dat.xishu=d1[i].xishu;
            i++;
        }
         else if(d1[i].zhishu>d2[j].zhishu)
        {
            p->dat.zhishu=d2[j].zhishu;
            p->dat.xishu=d2[j].xishu;
            p2->dat.zhishu=d2[j].zhishu;
            p2->dat.xishu=-d2[j].xishu;
            j++;
        }
         else
        {
            p->dat.zhishu=d1[i].zhishu;
            p->dat.xishu=d1[i].xishu+d2[j].xishu;
            p2->dat.zhishu=d1[i].zhishu;
            p2->dat.xishu=d1[i].xishu-d2[j].xishu;
            i++;
            j++;
        }
        he_tail->next=p;
        p->next=NULL;
        he_tail=p;
        cha_tail->next=p2;
        p2->next=NULL;
        cha_tail=p2;
    }
     // 將剩余的項加到表達式中
     if(sum1<sum2)
    {
         for(;j<sum2;j++)
        {
            node *p,*p2;
            p= new node;
            p2= new node;
            p->dat.zhishu=d2[j].zhishu;
            p->dat.xishu=d2[j].xishu;
            p2->dat.zhishu=d2[j].zhishu;
            p2->dat.xishu=-d2[j].xishu;
            he_tail->next=p;
            p->next=NULL;
            he_tail=p;
            cha_tail->next=p2;
            p2->next=NULL;
            cha_tail=p2;
        }
    }
     else if(sum1>sum2)
    {
        j=i;
         for(;j<sum1;j++)
        {
            node *p,*p2;
            p= new node;
            p2= new node;
            p->dat.zhishu=d2[j].zhishu;
            p->dat.xishu=d2[j].xishu;
            p2->dat.zhishu=d2[j].zhishu;
            p2->dat.xishu=d2[j].xishu;
            he_tail->next=p;
            p->next=NULL;
            he_tail=p;
            cha_tail->next=p2;
            p2->next=NULL;
            cha_tail=p2;
        }
    }
     // 輸出兩個表達式的和
    printf( " 兩個表達式的和為：\n ");
    output(he);
     // 輸出兩個表達式的差
    printf( " \n兩個表達式的差為：\n ");
    output(cha);
     // 表達式乘法
    node *chengfa;
    chengfa = new node;
    chengfa -> next = NULL;
     for(i= 0;i<sum1;i++)
    {
         for(j= 0;j<sum2;j++)
        {
            node *p;
            p = new node;
            p -> dat.zhishu = d1[i].zhishu + d2[j].zhishu;
            p -> dat.xishu = d1[i].xishu * d2[j].xishu;
            p->next=NULL;
            node *q;
            q = chengfa;
             while(q->next)
            {
                 if(q->next->dat.zhishu>p->dat.zhishu)
                {
                    p->next=q->next;
                    q->next=p;
                     break;
                }
                 else if(q->next->dat.zhishu==p->dat.zhishu)
                {
                    q->next->dat.xishu+=p->dat.xishu;
                     break;
                }
                q=q->next;
            }
             if(q->next==NULL)
            {
                p->next=q->next;
                q->next=p;
            }
        }
    }
    printf( " \n兩個表達式的乘積為：\n ");
    output(chengfa);
     for(i= 0;i< 30;i++)
        printf( " == ");
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 數據結構之一元多項式的加法和乘法數據結構——鏈表實現一元多項式的表示和加法線性結構2 一元多項式的乘法與加法運算【用鏈表實現一元多項式的加法和乘法運算】一元多項式的乘法與加法運算——鏈表實現【數據結構】一元多項式數據結構 C++ 單鏈表一元多項式的相加詳解線性結構 —— 一元多項式的乘法與加法運算數據結構實驗：一元多項式計算器（C++ 實現）數據結構題目---設計函數分別求兩個一元多項式的乘積與和。