链表 （自写模板）和一个简单的应用（多项式相加和相乘）

最新推荐文章于 2024-04-07 20:49:23 发布
最新推荐文章于 2024-04-07 20:49:23 发布
阅读量210 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kirito9943/article/details/82903838
版权

  

   CreateList(list_own *&L,int n)                         创建链表
   print(list_own *L)                                             打印链表
   List_insert(list_own *L,int i,int num)                 链表插入，插入在i之后。
   select(list_own *L,int i)                                     查找第i个元素
   revise(list_own *L,int i,int num)                        将第i个元素替换为
   list_spot_delete(list_own *L,int i)                      将链表中第i个节点删除
   DestroyList(list_own* &L)                                 删除链表
   ListEmpty(list_own* &L)                                   判断链表是否为空
   ListLength(list_own* L)                                     返回链表长度
   select_0(list_own *L,int num)                           查找链表中是否含有某个节点的值
   Connect(list_own *&L1,list_own *&L2)            将俩个链表连接在一起
   Insert(list_own*&L,list_own*&num,int n)          将一个节点插入到链表中

#include<bits/stdc++.h>
using namespace std;
struct list_own
{
    int num;
    list_own *next;
};
void CreateList(list_own *&L,int n)
{
    L=(list_own*)malloc(sizeof(list_own));
    list_own* p1=(list_own*)malloc(sizeof(list_own));
    L->next=NULL;
    p1=L;
    list_own* p;
    for(int i=0;i<n;i++)
    {
        int tmp_num;
        p=(list_own*)malloc(sizeof(list_own));
        scanf("%d",&tmp_num);
        p->num=tmp_num;
        p->next=p1->next;
        p1->next=p;
        p1=p;
    }
}
void print(list_own *L)
{
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        printf("%d ",p_i->num);
    }
    printf("\n");
}
void List_insert(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==0)
    {
        list_own*s=(list_own*)malloc(sizeof(list_own));
        s->next=tmp_p;
        L->next=s;
        s->num=num;
        return;
    }
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            list_own*s=(list_own*)malloc(sizeof(list_own));
            s->next=p_i->next;
            s->num=num;
            p_i->next=s;
            break;
        }
    }
}
int select(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            falg=true;
            return p_i->num;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return 0;
    }
}
void revise(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            p_i->num=num;
            falg=true;
            return ;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return ;
    }
}
void list_spot_delete(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==1)
    {
        L->next=(tmp_p->next);
        free(tmp_p);
        return ;
    }
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==(i-1))
        {
            list_own *q=p_i->next;
            p_i->next=((p_i->next)->next);
            q->next=NULL;
            free(q);
            return ;
        }
    }
}
void DestroyList(list_own* &L)
{
    list_own* p;
    while(L)
    {
       p=L->next;
       free(L);
       L=p;
    }
    printf("链表空间释放\n");
}
bool ListEmpty(list_own* &L)
{
    if(L->next==NULL) return true;
    else
    {
        return false;
    }
}
int ListLength(list_own* L)
{
    int ans=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        ans++;
    }
    return ans;
}
void select_0(list_own *L,int num)
{
    int t=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        t++;
       if(p_i->num==num)
       {
           printf("寻找成功，在%d位置",t);
           return ;
       }
    }
    printf("没有找到\n");
}
void Connect(list_own *&L1,list_own *&L2)
{
    for(list_own *tmp_L1=L1->next;;tmp_L1=tmp_L1->next)
    {
        if((tmp_L1->next)==NULL)
        {
            tmp_L1->next=L2->next;
            break;
        }
    }
    DestroyList(L2);
    printf("链表连接成功，头节点为第一个链表的头节点\n");
}
void Insert(list_own*&L,list_own*&num,int n)
{
    if(num>0)
    {
        int t=0;
        for(list_own *i=L->next;i!=NULL;i=i->next)
        {
           t++;
           if(t==n-1)
           {
               num->next=i->next;
               i->next=num;
               break;
           }
        }
    }
}
/*
功能:
   CreateList(list_own *&L,int n)             创建链表
   print(list_own *L)                         打印链表
   List_insert(list_own *L,int i,int num)     链表插入，插入在i之前。
   select(list_own *L,int i)                  查找第i个元素
   revise(list_own *L,int i,int num)          将第i个元素替换为
   list_spot_delete(list_own *L,int i)        将链表中第i个节点删除
   DestroyList(list_own* &L)                  删除链表
   ListEmpty(list_own* &L)                    判断链表是否为空
   ListLength(list_own* L)                    返回链表长度
   select_0(list_own *L,int num)              查找链表中是否含有某个节点的值
   Connect(list_own *&L1,list_own *&L2)       将俩个链表连接在一起
   Insert(list_own*&L,list_own*&num,int n)    将一个节点插入到链表中
*/
int main ()
{
}

多项式相加与相乘：

#include<bits/stdc++.h>
using namespace std;
struct list_own
{
    int num;
    list_own *next;
};
const int maxn=1e5;
int a[maxn];
void CreateList(list_own *&L,int n)
{
    L=(list_own*)malloc(sizeof(list_own));
    list_own* p1=(list_own*)malloc(sizeof(list_own));
    L->next=NULL;
    p1=L;
    list_own* p;
    for(int i=0;i<n;i++)
    {
        int tmp_num;
        p=(list_own*)malloc(sizeof(list_own));
        scanf("%d",&tmp_num);
        p->num=tmp_num;
        p->next=p1->next;
        p1->next=p;
        p1=p;
    }
}
void print(list_own *L)
{
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        printf("%d ",p_i->num);
    }
    printf("\n");
}
void List_insert(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==0)
    {
        tmp_p=NULL;
        list_own*s=(list_own*)malloc(sizeof(list_own));
        s->next=tmp_p;
        L->next=s;
        s->num=num;
        return;
    }
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            list_own*s=(list_own*)malloc(sizeof(list_own));
            s->next=p_i->next;
            s->num=num;
            p_i->next=s;
            break;
        }
    }
}
int select(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            falg=true;
            return p_i->num;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return 0;
    }
}
void revise(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            p_i->num=num;
            falg=true;
            return ;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return ;
    }
}
void list_spot_delete(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==1)
    {
        L->next=(tmp_p->next);
        free(tmp_p);
        return ;
    }
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==(i-1))
        {
            list_own *q=p_i->next;
            p_i->next=((p_i->next)->next);
            q->next=NULL;
            free(q);
            return ;
        }
    }
}
void DestroyList(list_own* &L)
{
    list_own* p;
    while(L)
    {
       p=L->next;
       free(L);
       L=p;
    }
    printf("链表空间释放\n");
}
bool ListEmpty(list_own* &L)
{
    if(L->next==NULL) return true;
    else
    {
        return false;
    }
}
int ListLength(list_own* L)
{
    int ans=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        ans++;
    }
    return ans;
}
void select_0(list_own *L,int num)
{
    int t=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        t++;
       if(p_i->num==num)
       {
           printf("寻找成功，在%d位置",t);
           return ;
       }
    }
    printf("没有找到\n");
}
void Connect(list_own *&L1,list_own *&L2)
{
    for(list_own *tmp_L1=L1->next;;tmp_L1=tmp_L1->next)
    {
        if((tmp_L1->next)==NULL)
        {
            tmp_L1->next=L2->next;
            break;
        }
    }
    DestroyList(L2);
    printf("链表连接成功，头节点为第一个链表的头节点\n");
}
void Insert(list_own*&L,list_own*&num,int n)
{
    if(num>0)
    {
        int t=0;
        for(list_own *i=L->next;i!=NULL;i=i->next)
        {
           t++;
           if(t==n-1)
           {
               num->next=i->next;
               i->next=num;
               break;
           }
        }
    }
}
/*
功能:
   CreateList(list_own *&L,int n)             创建链表
   print(list_own *L)                         打印链表
   List_insert(list_own *L,int i,int num)     链表插入，插入在i之后。
   select(list_own *L,int i)                  查找第i个元素
   revise(list_own *L,int i,int num)          将第i个元素替换为
   list_spot_delete(list_own *L,int i)        将链表中第i个节点删除
   DestroyList(list_own* &L)                  删除链表
   ListEmpty(list_own* &L)                    判断链表是否为空
   ListLength(list_own* L)                    返回链表长度
   select_0(list_own *L,int num)              查找链表中是否含有某个节点的值
   Connect(list_own *&L1,list_own *&L2)       将俩个链表连接在一起
   Insert(list_own*&L,list_own*&num,int n)    将一个节点插入到链表中
*/
int main ()
{
    list_own *La;
    list_own *Lb;
    int n,m,x;
     cout<<"规则如下："<<endl<<"1:格式为：a*x^0+b*x^1+c*x^2+......"<<endl;
     cout<<"2:输入1进入多项式相加，输入2进入多项式相乘"<<endl;
     scanf("%d",&x);
    if(x==1)
    {
    cout<<"请分别输入俩个多项式的最高次幂是多少"<<endl;
    scanf("%d%d",&n,&m);
    cout<<"输入系数a,b,c........."<<endl;
    CreateList(La,n);
    CreateList(Lb,m);
    list_own *Lc;
    Lc=(list_own*)malloc(sizeof(list_own));
    int t=0;
    int num1,num2;
    for(list_own *p1=La->next,*p2=Lb->next;p1!=NULL||p2!=NULL;)
    {
        if(p1!=NULL&&p2==NULL)
        {
            num2=0;
            num1=p1->num;
            p1=p1->next;
        }
        else if(p2!=NULL&&p1==NULL)
        {
            num1=0;
            num2=p2->num;
            p2=p2->next;
        }
        else
        {
            num1=p1->num;
            num2=p2->num;
            p1=p1->next;
            p2=p2->next;
        }
        List_insert(Lc,t++,num1+num2);
    }
    t=0;
    for(list_own *p1=Lc->next;p1!=NULL;p1=p1->next)
    {
        if(p1->next!=NULL) printf("%d*x^%d+",p1->num,t++);
        else
        {
            printf("%d*x^%d=0\n",p1->num,t++);
        }
    }
    }
    else if(x==2)
    {
            cout<<"请分别输入俩个多项式的最高次幂是多少"<<endl;
            scanf("%d%d",&n,&m);
            cout<<"输入系数a,b,c........."<<endl;
             CreateList(La,n);
             CreateList(Lb,m);
             list_own *Lc;
             Lc=(list_own*)malloc(sizeof(list_own));
             int tmp=0;
             int t=0;
             int t1=1,t2=1;
             for(list_own *p1=La->next;p1!=NULL;p1=p1->next)
             {
                 int tmp_num=0;
                 for(list_own *p2=La->next;p2!=NULL;p2=p2->next)
                 {
                     tmp_num=(p1->num*p2->num);
                     a[t1+t2]=tmp_num;
                     t2++;
                 }
                 t1++;
                 t2=1;
             }
             t2=ListLength(Lb);
             t1=ListLength(La);
             cout<<"t2:"<<t2<<endl;
             cout<<"t1:"<<t1<<endl;
             for(int i=2;i<=t1+t2;i++)
             {
                 List_insert(Lc,i-2,a[i]);
             }
              t=0;
             for(list_own *p1=Lc->next;p1!=NULL;p1=p1->next)
             {
                 if(p1->next!=NULL)
                 {
                     printf("%d*x^%d+",p1->num,t++);
                 }
                 else
                 {
                     printf("%d*x^%d\n",p1->num,t++);
                 }
             }
    }
    return 0;
}

 

shiyuKirito
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构 链表的应用】一元多项式相加及相乘 和对问题的分析
Irean_Lau的专栏
05-08 3289
一元多项式相乘，需要将一个多项式的每一项的指数与另一个多项式的每一项的指数相乘。 代码实现： 头文件以及函数声明： #ifndef _POLYN_H #define _POLYN_H #include #include #include using namespace std; #define _CRT_SECURE_NO_DEPRECAT
cpp链表实现一元多项式表示，相加，相乘
06-18
两个多项式相加需要遍历两个链表，并将具有相同指数的项合并。如果一个多项式中没有某个指数的项，那么另一个多项式的相应项可以直接保留： ```cpp Polynomial Polynomial::add(const Polynomial& other) const { ...
【链表实现】一元多项式相加相乘【详解相加相乘】
m0_74044018的博客
09-23 1522
利用链表知识，c++实现一个一元多项式的创建、相加和相乘，对于相加和相乘是我讲解的重点，有详细的注释
C语言链表实现一元多项式的相加和相乘
m0_73884264的博客
11-04 395
你可以定义一个函数 `insertNode`，该函数将根据指数的大小将结点插入到适当的位置，并合并具有相同指数的项。这个函数将遍历两个多项式链表，相同指数的项系数相减，然后将结果插入到新的链表中。在 `main` 函数中创建两个多项式，分别插入结点，然后调用相加和相减运算的函数，将结果打印出来，以验证运算的正确性。这个函数将遍历两个多项式链表，相同指数的项系数相加，然后将结果插入到新的链表中。首先，需要定义一个多项式结点的数据结构，包含系数和指数，并且要有指向下一个结点的指针。这将作为链表的结点类型。
线性表练习：一元多项式相加、一元多项式相乘
xiaozhi6yyy18的博客
04-07 282
打开源程序UnipolyAdd.cpp，其中的代码实现的是两个一元多项式的求和运算。程序已给出一元多项式存储结构的定义、建立存储结构的函数、输出一元多项式的函数、及主函数。请补充完成一元多项式的求和运算的函数编写。多项式某一项的系数可能为0，系数为0的多项式项为无效项，建立多项式时不存储系数为0的项，输出时也不输出系数为0的项。
利用链表实现多项式的相乘以及相加
cendien的博客
09-01 2966
/*利用链表实现多项式的相乘以及相加 两个多项式 多项式1：3X^4 + 5X^2 +6X - 2 多项式2：5X^20 -7X^4 +3X 输入数据： 4 3 4 5 2 6 1 -2 0 输入数据对于每一个多项式而言，先指定多项式的项数，然后 ····· 3 5 20 -7 4 3 1 输入每一项的系数与指数 输出数...
一元多项式的相加和相减操作(链表)
编程技巧分享
03-27 5638
教你学会如何用链表实现一元多项式的加减。
一元多项式相加和相乘
jingshen9992的博客
03-22 1124
#include <stdio.h> #include <stdlib.h> //定义一元多项式链表 typedef struct Polynode{ int coef;//系数 int exp;//指数 Polynode *next; }Polynode,*Polylist; //多项式约定为降次 指数为0时结束 //尾插法建立多项式 Polylist Mult(Polylist p1, Polylist p2); Polylist polycreate() { Pol.
使用链表实现多项式相加和相乘
小石头会长成大石头么？
10-23 153
下面是《数据结构与算法分析C语言描述》中的40页练习 polynomialList.h #ifndef POLYNOMIAL_LIST_H #define POLYNOMIAL_LIST_H typedef struct node { int coefficient; int exponent; node * next; } * Node; typedef Node polynomial; void error(const char []); polynomial generatePoly
使用链表实现两个多项式相加和相乘
热门推荐
qq_15161183的博客
05-17 1万+
设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 输出格式: 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。 输入样例: 4 3 4 -5 2
数据结构实验1.5：一元多项式的相加和相乘.doc
10-29
这篇实验报告涉及的是数据结构中的一个经典问题：一元多项式的操作，包括创建、输出、撤销以及相加和相乘。下面将详细解释这些概念及其实现。 首先，一元多项式是由不同指数的项（每个项包含一个系数和一个指数）...
多项式相加和相乘c语言源代码
12-10
多项式相加和相乘C语言源代码 本篇文章将对C语言中多项式相加和相乘的源代码进行详细的解释和分析。 一、多项式相加 多项式相加是指将两个多项式相加，生成一个新的多项式。在C语言中，我们可以使用链表来实现...
用链表实现多项式相乘以及相加
04-10
在链表实现多项式相乘和相加中，需要定义一个链表结构体，包括基数、指数和指针三个成员变量。然后，需要实现创建多项式、输出多项式、加法和乘法等函数。 创建多项式函数CreatePloyn的作用是根据用户输入的基数和...
两个高次多项式加法和乘法运算课程设计
04-09
3. 两个多项式相加，输出和多项式； 4. 两个多项式相乘，输出积多项式。 系统功能设计： 为了实现设计要求，我们需要设计一个能够实现多项式运算的系统。系统主要由三个模块组成：输入模块、计算模块和输出模块。 ...
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
C语言实现稀疏一元多项式相乘
3. **多项式创建**：在程序中，我们需要设计一个构造函数，如`Creat(int k, char c)`，用于输入项数k和系数c，创建一个表示多项式的新链表。 4. **多项式相加**：实现多项式的相加涉及遍历两个链表，并对相同指数的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值