单向链表实现多项式加和乘--自己写数据结构

最新推荐文章于 2021-01-14 19:07:01 发布

XIAO_PING_PING

最新推荐文章于 2021-01-14 19:07:01 发布

阅读量1.1k

点赞数

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/XIAO_PING_PING/article/details/41870131

版权

数据结构专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了如何利用单向链表结构来表示并操作多项式，包括多项式的创建、添加、删除、排序以及多项式间的加法和乘法运算，并通过代码实例展示了实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

用单项链表实现多项式数据结构和代码如下（由于时间原因多项式乘法的函数没用实现，读者可以在自己完善）：

存放结构体的头文件polylist.h

#ifndef _H_POLYLIST_
#define _H_POLYLIST_

typedef struct _Poly_Node
{
    int ratio;  //系数 
    int power;  //幂
    
    struct _Poly_Node* next;       
}Node,*pNode;

typedef struct _Poly_List
{
    struct _Poly_Node* next;   
}PolyList,*pPolyList;

pPolyList init_list_header(void);
pNode poly_add_node(pPolyList plist,int ratio,int power);
int poly_delete_node(pPolyList plist,int power);
int print_poly(pPolyList plist);
int poly_bubble_sort(pPolyList plist);
pPolyList poly_addcat(pPolyList pfir,pPolyList psec);
pPolyList poly_add(pPolyList pfir,pPolyList psec);

#endif

数据结构函数实现文件polylist.c如下：

/**************************************
时间：2014.12.11
作者：XIAO_PING_PING
内容：单向链表表示多项式的加法和乘法 
功能：学习写数据结构
 
***************************************/
#include <string.h>
#include <stdlib.h>

#include "polylist.h"

/*创建一个多项式链表头*/
pPolyList init_list_header(void)
{
    pPolyList phead;
    
    phead = (PolyList *)malloc(sizeof(PolyList));
    phead->next = NULL;
    
    return phead;     
} 

/*往多项式里面添加项*/
pNode poly_add_node(pPolyList plist,int ratio,int power)
{
    pNode ptail,pre,p;
    
    ptail = (Node *)malloc(sizeof(Node));
    ptail->ratio = ratio;
    ptail->power = power;
    ptail->next = NULL;
    
    if(NULL == plist->next)
    {
        plist->next = ptail;       
        printf("多项式链表插入点：系数=%d，幂值=%d\n",ptail->ratio,ptail->power); 
        
        return ptail; 
    } 
    
    pre = plist->next;
    while(pre)
    {
        p = pre;
        pre = pre->next;
    }
    p->next = ptail;
    printf("多项式链表插入点：系数=%d，幂值=%d\n",ptail->ratio,ptail->power); 
    
    return ptail; 
}

/*删除多项式中对应幂值的项*/
int poly_delete_node(pPolyList plist,int power)
{
    pNode pre,p;
    
    if(NULL == plist->next)
    {
        printf("多项式链表为空"); 
        return  -1;       
    }
    
    pre = plist->next;
    p = pre;
    while(NULL != p->next)
    {
        pre = p;
        if(power == pre->next->power)
        {
             pre = pre->next;
             p->next = pre->next;
             
             free(pre); 
             printf("删除多项式链表中幂值为%d的项\n",power);                  
        }
        p = p->next; 
    } 
    
    if(power == plist->next->power)
    {
        p = plist->next;
        
        plist->next = plist->next->next;
        
        free(p);
        printf("删除多项式链表中幂值为%d的项\n",power);        
         
    }
    
    return 0; 
}
/*打印多项式*/
int print_poly(pPolyList plist)
{
    pNode p;
    
    p = plist->next;
    
    if(NULL == p)
    {
        printf("该多项式为空。\n");  
        return -1;              
    } 
    
    printf("遍历输出多项式:\n");  
    printf("Y = ");   
    while(NULL != p)
    {
       printf("%d X%d + ",p->ratio,p->power);
       p = p->next;          
    }        
         
    return 0;
} 
/*多项式排序*/
int poly_bubble_sort(pPolyList plist)
{
    int tpower,tratio;
    pNode p,pre,ptemp;
    
    if(NULL == plist->next)
    {
        printf("多项式链表为空\n"); 
        return -1;   
    }
    
    if(NULL == plist->next->next)
    {
        printf("多项式链表只有一项\n"); 
        return -2;          
    }
    
    p = plist->next;
    pre = p;
    while(p)
    {
        pre = p;
        while(pre->next)
        {
           // ptemp = pre;
            if(pre->next->power == p->power)
            {
                ptemp = pre->next;
                                
                p->ratio += pre->next->ratio;
                pre->next = pre->next->next ;
                
                free(ptemp);
                if(NULL == pre->next)
                {
                    break;
                }
            }
            else if(pre->next->power < p->power)
            {
                tpower = p->power;
                tratio = p->ratio;
                p->power = pre->next->power;
                p->ratio = pre->next->ratio;
                pre->next->power = tpower;
                pre->next->ratio = tratio;
                //ptemp = p;
                //p = pre->next;
                
                //pre->next = ptemp;
                //                  
            }
            else
            {          
            }       
            pre = pre->next;          
        }            
        p = p->next;     
    }         
}
/*合并两个多项式，把第二个多项式的全部节点添加到第一个多项式后面*/
pPolyList poly_addcat(pPolyList pfir,pPolyList psec)
{
    PolyList *p = pfir;
    //ptotal = (PolyList *)malloc(sizeof(PolyList));
    
    Node *pre = pfir->next;
    
    //p = pfir->next; 
    if(NULL == pre)
    {
        pfir->next = psec->next;         
    }
    else
    {
        while(pre->next)
        {
            //pre = p;
            pre = pre->next;        
        }    
        pre->next = psec->next;
    }
    free(psec);   
    
    return  pfir; 
}

/*多项式加法*/
pPolyList poly_add(pPolyList pfir,pPolyList psec)
{
    PolyList *p = pfir;
    //ptotal = (PolyList *)malloc(sizeof(PolyList));
    
    p = poly_addcat(pfir,psec);
    poly_bubble_sort(p);
    //return poly_bubble_sort(poly_addcat(pfir,psec));   
    return p;            
}

测试文件test.c如下

#include <string.h>
#include <conio.h>

#include "polylist.h"

int main()
{
    pPolyList polyone,polytwo,polyadd;
    
    printf("多项式一：\n");
    polyone = init_list_header();  
    poly_add_node(polyone,2,11);  
    poly_add_node(polyone,3,7);  
    poly_add_node(polyone,23,11);
    poly_add_node(polyone,1,13);
    poly_add_node(polyone,32,45);
    poly_add_node(polyone,23,32);
    poly_add_node(polyone,3,343);
    poly_add_node(polyone,34,414);
    poly_add_node(polyone,23,7);
    poly_add_node(polyone,12,44);
    print_poly(polyone);  
    printf("\n");
    printf("\n");
    printf("多项式二：\n");
    polytwo = init_list_header();  
    poly_add_node(polytwo,2,11);  
    poly_add_node(polytwo,44,13);  
    poly_add_node(polytwo,23,34);
    poly_add_node(polytwo,43,32);
    poly_add_node(polytwo,32,45);
    poly_add_node(polytwo,23,32);
    poly_add_node(polytwo,3,343);
    poly_add_node(polytwo,34,44);
    poly_add_node(polytwo,23,7);
    poly_add_node(polytwo,12,464);
    print_poly(polytwo); 
    printf("\n");
    printf("\n");
   
    //polyadd = init_list_header();    
   // polyadd = poly_addcat(polyone,polytwo);
    //polyadd = init_list_header();  
    printf("合并多项式一和二：\n");
    polyadd = poly_add(polyone,polytwo);
    
    print_poly(polyadd);   
    //poly_bubble_sort(polyone);
    
    //poly_delete_node(polyone,2);
    //poly_delete_node(polyone,4);
    //poly_delete_node(polyone,2);
    //poly_delete_node(polyone,3);
   // 
    getch();
}

以上文件运行结果如下：