线性表的抽象数据类型的实现

原创 已于 2022-05-25 17:10:31 修改 · 556 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言

于 2022-04-30 13:29:56 首次发布
本文详细介绍了如何使用C语言实现线性表的抽象数据类型，包括线性表的基本操作如插入、删除、查找等，并探讨了其在数据结构中的应用。

实验内容（方法和步骤）：

设计一个一元稀疏多项式简单计算器。

要求：

（1）输入并建立多项式

（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2……,cn,en,其中n为多项式的项数，ci和ei分别为第i项的系数和指数，序列按指数降序排列。

（3）实现两个多项式相加并输出

（4）实现俩个多项式相减并输出

（5）实现两个多项式相乘并输出

代码源码：

实现加减法

#include <stdio.h>         
#include <malloc.h>           
#define ERROW 0 
 
typedef struct Lnode {
    float c;
    int e;
    struct Lnode* next;
}Lnode;
 
Lnode *Creat_list();
Lnode *addition(Lnode *head1, Lnode *head2);
Lnode *substraction(Lnode *head1, Lnode *head2);
Lnode *List_insert(Lnode *head,Lnode *p);
void List_Traverse(Lnode *head);
void List_sort();
 
int main() {
    int judge;
    Lnode *head1, *head2, *head3;
    head1 = Creat_list();
    head2 = Creat_list();
    head3 = addition(head1, head2);
    head4 = substraction(head1, head2);
    head5 = Mult(head1,head2);
    }
    List_Traverse(head3);
    List_Traverse(head4);
    List_Traverse(head5);
    
}//main
 
Lnode *List_insert(Lnode *header, Lnode *p) {
    Lnode *rear = NULL;
    rear = header;
    
    if (header == NULL) {
        header = p;
        p->next = NULL;
    }//if
    if(rear != NULL) {
        while (1) {
            if (rear->next == NULL) {
                break;
            }//if
            rear = rear->next;
        }//while
        rear->next = p;
        p->next = NULL;
    }//if
    return header;
 
}//List_insert
 
Lnode *Creat_list(){
    Lnode *head = NULL;
    Lnode *p = NULL, *q = NULL;
 
    if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
        return ERROW;
     }
    if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
        return ERROW;
    }
    head->next = q;
    p = q;
    p->next = NULL;
 
 
    while (1) {
        scanf("%f%d", &q->c, &q->e);
        if (getchar()!='\n') {
            if (!(q = (Lnode *)malloc(sizeof(Lnode)))) {
                return ERROW;
            }
            p->next = q;
            p = q;
            p->next = NULL;
        }
        else {
            break;
        }//else
    }//while
 
    return head;
}//Creat_list
  
Lnode *addition(Lnode *head1, Lnode *head2) {
    float c;
    Lnode *p1 = NULL, *p2 = NULL, *p = NULL, *q = NULL, *head = NULL, *header = NULL;
    
    p1 = head1->next;
    p2 = head2->next;
    if (!(head = (Lnode *)malloc(sizeof(Lnode)))) {
        return ERROW;
    }
    header = head->next;
    header = NULL;
 
    while (p1 != NULL&&p2 != NULL) {
        if (p1->e > p2->e) {
            if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
                return ERROW;
            }//if
            p->c = p1->c;
            p->e = p1->e;
            p1 = p1->next;
 
            header = List_insert(header, p);
        }//if
        else if(p1->e == p2->e){
            if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
                return ERROW;
            }
            p->c = p1->c + p2->c;
            p->e = p1->e;
            p1 = p1->next;
            p2 = p2->next;
 
            header = List_insert(header, p);
        }//else if
        else if (p1->e < p2->e) {
            if (!(p = (Lnode *)malloc(sizeof(Lnode)))) {
                return ERROW;
            }//if
            p->c = p2->c;
            p->e = p2->e;
            p2 = p2->next;
 
            header = List_insert(header, p);
        }//else if
    }//while
    while (p1 == NULL) {
        if (p2 == NULL) {
            break;
        }//if
 
        header = List_insert(header, p2);
        p2 = p2->next;
    }//while
    while (p2 == NULL) {
        if (p1 == NULL) {
            break;
        }//if
 
        header = List_insert(header, p1);
        p1 = p1->next;
    }//while
 
    return header;
}//addition
  
Lnode *substraction(Lnode *head1, Lnode *head2) {
    Lnode *p = head2, *head = NULL;
 
    while (p != NULL) {
        p->c = -1 * p->c;
        p = p->next;
    }//while
 
    head = addition(head1, head2);
 
    return head;
}//substraction
 
Polynomial Mult(Polynomial P1,Polynomial P2)
{
    Polynomial P,Rear,t1,t2,t;
    int c,e;
    if(!P1||!P2) return NULL;
    t1=P1;
    t2=P2;
    P=(Polynomial)malloc(sizeof(struct PolyNode));
    P->link=NULL;
    Rear=P;
    while(t2){
        Attach(t1->coef*t2->coef,t1->expon+t2->expon,&Rear);
        t2=t2->link;    
    }
    t1=t1->link;
    while(t1){
        t2=P2;
        Rear=P;    
        while(t2){
            e=t1->expon+t2->expon;
            c=t1->coef*t2->coef;
            while(Rear->link&&Rear->link->expon>e)    
                Rear=Rear->link;
            if(Rear->link&&Rear->link->expon==e){    
                if(Rear->link->coef+c)            
                    Rear->link->coef+=c;
                else{                                
                    t=Rear->link;
                    Rear->link=t->link;
                    free(t);
                }
            }else{                                        
                t=(Polynomial)malloc(sizeof(struct PolyNode));    
                t->coef=c;t->expon=e;
                t->link=Rear->link;                                
                Rear->link=t;Rear=Rear->link;
            }
            t2=t2->link;
        }
        t1=t1->link;
    }
    t2=P;
    P=P->link;
    free(t2);

    return P;
}
 
void List_Traverse(Lnode *head) {
    Lnode *p = head;
    if (p == NULL) {
        printf("zero");
    }
    while (p != NULL) {
        printf("%f %d ", p->c, p->e);
        p = p->next;
    }//while
}//List_Traverse
 

实现乘法

#include <stdio.h>
#include <malloc.h> 

 typedef struct PolyNode *Polynomial;
 struct PolyNode{
    int coef;
    int expon;
    Polynomial link;
 };

 void Attach(int c,int e,Polynomial *pRear) //pRear是指针的指针 
 {
    Polynomial P;

    P=(Polynomial)malloc(sizeof(struct PolyNode));
    P->coef=c; //对新结点赋值 
    P->expon=e;
    P->link=NULL;
    (*pRear)->link=P; //修改pRear的值 
    *pRear=P;
 }
 Polynomial ReadPoly()
 {
    Polynomial P,Rear,t;
    int c,e,N;

     scanf("%d",&N);
     P=(Polynomial)malloc(sizeof(struct PolyNode)); //链表头空结点 
     P->link=NULL;
     Rear=P;
    while(N--){
        scanf("%d%d",&c,&e);
        Attach(c,e,&Rear); //将当前项插入多项式尾部 

     }
     t=P;P=P->link;free(t); //删除临时生成的头结点 
     return P;
 }

 Polynomial Add(Polynomial P1,Polynomial P2)
 {
    Polynomial front,rear,temp;
    int sum;
    rear=(Polynomial)malloc(sizeof(struct PolyNode));
    front=rear; /*由front记录结果多项式链表头结点*/
    while(P1&&P2){ /*当两个多项式都有非零项待处理时*/ 
        if(P1->expon==P2->expon){
            sum=P1->coef+P2->coef;
            if(sum){
            Attach(sum,P1->expon,&rear);
            P1=P1->link;
            P2=P2->link;

            }else{
                P1=P1->link;
                P2=P2->link;

             }
         }else if(P1->expon>P2->expon){
            Attach(P1->coef,P1->expon,&rear);
            P1=P1->link;
         }else{
            Attach(P2->coef,P2->expon,&rear);
            P2=P2->link;
         }
     }
     /*将未处理完的另一个多项式的所有节点依次复制到结果多项式中去*/ 
     while(P1){
        Attach(P1->coef,P1->expon,&rear);
        P1=P1->link;
     }
     while(P2){
        Attach(P2->coef,P2->expon,&rear); 
        P2=P2->link;
     }
    rear->link=NULL;
    temp=front;
    front=front->link; /*令front指向结果多项式第一个非零项*/ 
    free(temp);        /*释放临时空表头结点*/ 
    return front;
  } 

/*采用逐项插入的方法，将P1当前项乘以P2的当前项，并插入到结果多项式中，关键是要找到插入的位置*/  
/*初始结果多项式由P1第一项乘以P2各项获得*/ 
Polynomial Mult(Polynomial P1,Polynomial P2)
{
    Polynomial P,Rear,t1,t2,t;
    int c,e;

    if(!P1||!P2){
        return NULL;
    }
    t1=P1;t2=P2;
    P=(Polynomial)malloc(sizeof(struct PolyNode));P->link=NULL;
    Rear=P;
    while(t2){ //P1第一项乘以P2各项得到初始结果多项式 
        Attach(t1->coef*t2->coef,t1->expon+t2->expon,&Rear);

        t2=t2->link;
    }
    t1=t1->link;
    while(t1){
        t2=P2;Rear=P;

        while(t2){
            e=t1->expon+t2->expon;
            c=t1->coef*t2->coef;
            while(Rear->link&&Rear->link->expon>e)
            Rear=Rear->link;
            if(Rear->link&&Rear->link->expon==e){
                if(Rear->link->coef+c)
                 Rear->link->coef+=c;
                else{
                    t=Rear->link;
                    Rear->link=t->link;
                    free(t);
                }
            }
            else{
                t=(Polynomial)malloc(sizeof(struct PolyNode));
                t->coef=c;
                t->expon=e;
                t->link=Rear->link;
                Rear->link=t;
                Rear=Rear->link;
            }
            t2=t2->link;
            //printf("%d,%d\n",Rear->coef,Rear->expon);


        }
        t1=t1->link; 
    }
    t2=P;P=P->link;free(t2);
    return P;

}

 void PrintPoly(Polynomial P)
 {
    int flag=0;  //辅助调整输出格式用 
    if(!P){
        printf("0 0\n");
         return;
     } 
     while(P){
        if(!flag)
         flag=1;
        else 
          printf(" ");
          printf("%d %d",P->coef,P->expon);
          P=P->link;
     }
 } 
 int main()
 {
    Polynomial P1,P2,PS,PP;
    P1=ReadPoly();

    P2=ReadPoly();

    PP=Mult(P1,P2);
    PrintPoly(PP);
    printf("\n");
    PS=Add(P1,P2);
    PrintPoly(PS); 

    return 0;
 }
 

Peachen
关注
c语言 线性表抽象数据类型定义，存储结构，应用
10-04
线性表的讲解，分析。 线性表的抽象数据类型定义 线性表的存储结构 线性表的应用
两个多项式相加及相乘
寒梅煮雪
11-18 3150
#include <stdio.h> #include <malloc.h> typedef struct PolyNode *Polynomial; struct PolyNode{ int coef; int expon; Polynomial link; }; void Attach(int c,int e,Polynomial *pRear) //pRear是指
数据结构总结 第二章 线性表 抽象数据类型的具体实现
dekangzhu7337的博客
07-06 541
#include<stdio.h> #include<stdlib.h> #include<iostream> #define MAXSIZE 1000 #define ERROR 0 #define OK 1 using namespace std; typedef int Status; typedef int ElemType...
两个多项式的相加&相乘
hj_503218859的博客
10-04 929
两个多项式的相加&相乘 #include <stdio.h> #include <stdlib.h> typedef struct polynomial //建立表示多项式的结构体 { int x[2]; struct polynomial *next; }POL; POL *creatlist (int n); POL *addition (POL*head1, POL*head2,int n); void output (POL *head); P
线性表抽象数据类型实现与基本操作实验
本实验指导共包含七个实验项目，其中第一个实验“线性表的抽象数据类型的实现”作为整个系列的基础，旨在帮助学生深入理解线性表的基本概念、操作逻辑及其在不同存储结构下的具体实现方式。通过该实验，学习者将掌握...
线性表抽象数据类型实现实验报告：顺序与链式存储结构及基本算法的实现
实验内容包括顺序表的基本操作实现，要求数据元素类型ElemType取整型int。在顺序存储结构下，实现了以下算法： 1. 创建任意整数线性表（即线性表的元素值随机在键盘上输入），长度限定在20之内； 2. 打印（遍历）该...
数据结构基于C语言的抽象数据类型实现：线性表顺序与链式存储结构设计及应用
最新发布
08-29
内容概要：本文深入解析《数据结构》C语言版（第3版）中“抽象数据类型的表示与实现”一节，系统阐述了抽象数据类型（ADT）的理论定义与C语言实现方法。通过“三元组”（数据对象、数据关系、基本操作）规范描述ADT...
线性表的抽象数据类型的实现实验报告.pdf
06-07
线性表的抽象数据类型的实现实验报告 本实验报告旨在实施线性表的抽象数据类型，包括顺序存储结构和链式存储结构的实现。实验的目的是掌握线性表的基本操作，熟练掌握顺序表和链表基本算法的实现，并掌握利用线性表...
C++实现线性表抽象数据类型模板
"该资源是关于数据结构...总结起来，这个资源提供了线性表的C++实现框架，强调了抽象数据类型的定义和操作，并预告了线性表在实际问题中的应用。通过学习这部分内容，读者可以掌握如何在C++中高效地处理线性数据结构。
抽象数据类型线性表的定义与实现
cp0328的博客
09-12 9478
最近刚刚上完数据结构的第一章，好久没有写线性表了，正好借着老师的作业温习一下，主程序实现的就是简单的list有序合并。不多比比，直接上代码 第一部分 de.hpp文件 // // main.cpp // test // // Created by 蔡鹏 on 2018/9/4. // Copyright © 2018年 蔡鹏. All rights reserved. // #ifnd...
线性表的抽象数据类型
xingyyn78的博客
01-29 756
/*线性表抽象数据类型*/ public interface List { public void clear(); //移除线性表的所有对象、 public void insert(Object item); //在当前位置插入对象 public void append(Object item);
抽象数据类型——线性表
我的博客
09-01 608
一、线性表的特点： 1.存在惟一的一个“第一个”的元素 2.存在惟一的一个“最后一个”的元素 3.除第一个以外，每个元素均只有一个前驱 4.除最后一个以外，每个元素均只有一个后继 二、线性表的基本操作 1. InitList(&L) 操作结果：构造一个空的线性表L 2.DestroyList(&L) 初始条件：线性表L已存在 操作结果：销毁线性表L 3.ClearL
数据结构 -- 多项式相加和相乘
古的博客
09-08 3886
这是数据结构的实验~~ 由于某些实验要上交，所以一部分的程序的代码改为英语注释了 这是求解多项式相加和相乘的算法实现。 采用线性表就可以实现了。 代码可能有点繁杂，因为线性表的实现也包括在里面了。   Experiment1_1.h ，算法的实现的头文件。 /* Experiment1_1.h */ // - - - - - - - - - - - - - - - - - - -...
线性表及抽象数据类型
水清_木秀的博客
11-27 1636
线性表定义线性表：由零个或多个数据元素组成的有限序列。所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。例如： 当天黑队伍解散各自回家了，队伍《梦之队》还在，只不过队伍没人，解散了。明天大家来集合，队伍又有人了。所以元素为0时，表还是有的。特点： 1、线性表是一个序列，也就是说元素之间是有个先来后到的。 2、若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他
数据结构实验一顺序表的抽象数据类型的实现
m0_57124079的博客
04-13 1490
顺序表的抽象数据类型的实现 （插入、删除、查找、倒置、合并、交集）
抽象数据类型的表示与实现
yzkzoo
09-18 982
一、抽象数据类型定义（ADT）作用：抽象数据类型可以使我们更容易描述现实世界。例：用线性表描述学生成绩表，用树或图描述遗传关系。定义：一个数学模型以及定义在该模型上的一组操作。关键：使用它的人可以只关心它的逻辑特征，不需要了解它的存储方式。定义它的人同样不必要关心它如何存储。例：线性表这样的抽象数据类型，其数学模型是：数据元素的集合，该集合内的元素有这样的关系：除第一个和最
两个求和符号相乘
热门推荐
麦地与诗人
06-14 3万+
在机器学习中，经常会遇到有含有两个求和符号的公式，如，∑i=1M∑j=1N\sum^M_{i=1} \sum^N_{j=1}∑i=1M​∑j=1N​，一开始，我总是不能够理解这是一种怎样的运算，后来看到下面的解释觉得自己顿悟： 有两个∑\sum∑的时候就有两个变量，是一个不变的情况下另一个从头到尾改变，然后之前那个再变一下，第二个再从头到尾变，一直到第一个变量变到最后，把这个过程中的项加起来！ ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值