线性表及多项式的运算(实验一)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_37360631/article/details/79632611

打包成zip包。
学号,姓名,项目名

readme文件
1.给出需求书,用户需要什么需求
2.详细设计要求,给出架构,功能设计,数据库设计,UI界面设计
3.定义头文件,给出.h,.cpp,.exe文件
4.测试报告,单链表给出多个测试报告,使用数据要不一样。给出测试案例。随机数10个数。
5.软件使用说明书,在什么结构下使用,什么环境下,按什么流程,怎么使用。
6.实验报告

code

可执行文件
运行可执行文件时候,里面要有姓名和学号。
******************************-
姓名
学号
项目名称
日期
版本号码
*******************************-

实验要求:
1.完成顺序表的初始化,查找,插入,删除,输出,撤销。

#include<iostream>
using namespace std;
typedef int ElementType;
typedef int Status;

//数序表的存储
typedef struct{
    int n;              //顺序表的长度
    int maxLength;      //顺序表的最大长度
    ElementType *element;   //存储空间的首地址
}seqList;

//顺序表的初始化
Status Init(seqList *l,int msize){
    l->maxLength=msize;
    l->n=0;
    l->element=(ElementType *)malloc(sizeof(ElementType )*msize);
    if(!l->element){
        return 0;
    }
    return 1;
}

//顺序表的插入,插入的位置为i+1的位置,插入的元素是x
Status Insert(seqList *l,int i,int x){
    if(i<-1||i>l->n-1) return 0;      //插入的位置不存在
    if(l->n==l->maxLength) return 0;  //线性表已经满了
    //后移
    for(int j=l->n-1;j>i;i--){ l->element[j+1]=l->element[j];}
    //插入
    l->element[i+1]=x;
    l->n++;
    return 1;
}

//顺序表的打印
Status Output(seqList l){
    if(!l.n) return 0;  //链表不为空
    for(int i=0;i<l.n-1;i++){ cout<<l.element[i];}
    cout<<endl;
    return 1;
}

//删除顺序表
Status Destroy(seqList *l){
    l->n=0;
    l->maxLength=0;
    free(l->element);
    return 1;
}

//顺序表的元素的删除,下标为i
Status Delete(seqList *l,int i){
    if(i<0||i>l->n-1) return 0; //越界
    for(int j=i;j<l->n;j++){ l->element[j]=l->element[j+1];}
    l->n--;
    return 1;
}

//顺序表的存储
Status Find(seqList l,int i,ElementType *x){
    if(i<0||i>l.n-1) return 0;
    *x=l.element[i];       //取出下标为i的元素,通过x返回
    return 1;
}



int main(){
    int x;
    seqList list;
    Init(&list,10);
    for(int i=0;i<9;i++){
        Insert(&list,i-1,i);
    }
    Find(list,3,&x); cout<<x<<endl;
    Output(list);
    Delete(&list,0);
    Output(list);
    Destroy(&list);
    return 0;
}

2.完成带表头结点单链表的初始化,查找,插入,删除,输出,撤销。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
typedef int ElementType;
typedef int Status;
typedef struct node{
    ElementType value; //数据域
    struct node *link; //指针域
}node;
typedef struct{
    struct node *head;  //头指针
    int n;              //链表的真实长度
}Headerlist;

Status Init(Headerlist *l){
    l->head=(node *)malloc(sizeof(node));
    if(!l->head) return 0;   //申请空间失败 
    l->n=0;
    l->head->link=NULL;   
    return 1;
}

//在下标为i+1的位置插入x 
Status Insert(Headerlist *l,int i,ElementType x){
    if(i<-1 ||i>l->n-1) return 0;

    node *q=l->head;
    for(int j=0;j<=i;j++) q=q->link; //q是待插入结点的前驱结点,ai

    node *p;            //生成带插入的结点 
    p=(node *)malloc(sizeof(node ));
    p->value=x; 

    p->link=q->link;
    q->link=p;
    l->n++;
    return 1;
}

Status Output(Headerlist l){
    if(!l.n) return 0;  //空链表
    node *p=l.head->link;
    while(p){
        cout<<p->value<<" ";
        p=p->link;
    } 
    cout<<endl;
    return 1;
}
//删除下标为i的元素 
Status Delete(Headerlist *l,int i){
    if(i<0||i>l->n-1) return 0;
    if(!l->n) return 0;
    node *p,*q;
    p=l->head;
    for(int j=0;j<=i-1;j++) p=p->link;  //p是待删除结点的前驱结点
    q=p->link;      //q是待删除结点
    p->link=q->link; 
    free(q);
    l->n--;
    return 1;
}

//查找下标为i的元素,通过x返回 
Status Find(Headerlist l,int i,ElementType *x){
    if(i<0||i>l.n-1) return 0;
    node *p;
    p=l.head;
    for(int j=0;j<=i;j++) p=p->link;
    *x=p->value;
    return 1; 
}

int main(){
    int i,x;
    Headerlist list;
    Init(&list);
    for(int i=0;i<9;i++){
        Insert(&list,i-1,i);
    }
    cout<<"the headerlist is :"<<endl;
    Output(list);
    Delete(&list,0);
    cout<<"the headerlist is: "<<endl;
    Output(list);
    Find(list,0,&x);
    cout<<"the value is :";
    cout<<x<<endl;
    return 0;
}

3.以第二题带表头结点单链表为存储结构,编写代码,实现单链表的逆置操作。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
typedef int ElementType;
typedef int Status;
typedef struct node{
    ElementType value; //数据域
    struct node *link; //指针域
}node;
typedef struct{
    struct node *head;  //头指针
    int n;              //链表的真实长度
}Headerlist;

Status Init(Headerlist *l){
    l->head=(node *)malloc(sizeof(node));
    if(!l->head) return 0;   //申请空间失败 
    l->n=0;
    l->head->link=NULL;   
    return 1;
}

//在下标为i+1的位置插入x 
Status Insert(Headerlist *l,int i,ElementType x){
    if(i<-1 ||i>l->n-1) return 0;

    node *q=l->head;
    for(int j=0;j<=i;j++) q=q->link; //q是待插入结点的前驱结点,ai

    node *p;            //生成带插入的结点 
    p=(node *)malloc(sizeof(node ));
    p->value=x; 

    p->link=q->link;
    q->link=p;
    l->n++;
    return 1;
}

Status Output(Headerlist l){
    if(!l.n) return 0;  //空链表
    node *p=l.head->link;
    while(p){
        cout<<p->value<<" ";
        p=p->link;
    } 
    cout<<endl;
    return 1;
}

//带表头链表的逆置
Status Reverse(Headerlist *L){
    node *p,*s,*t;
    p=L->head;
    s=p->link;
    while(s->link){
        t=s->link;
        s->link=p;
        p=s;
        s=t;
    }
    s->link=p;  //处理最后一个结点
    L->head->link->link=NULL; 
    L->head->link=s; 
    return 1;
} 

int main(){
    int i,x;
    Headerlist list;
    Init(&list);
    for(int i=0;i<9;i++){
        Insert(&list,i-1,i);
    }
    cout<<"The original headerlist is : "<<endl;
    Output(list);
    Reverse(&list);
    cout<<"After reversion,the heaserlist is: "<<endl;
    Output(list);
    return 0;
}

4.以第二题所表示的带表头结点的单链表为存储结构,实现单链表排序成为有序链表的操作。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
typedef int ElementType;
typedef int Status;
typedef struct node{
    ElementType value; //数据域
    struct node *link; //指针域
}node;
typedef struct{
    struct node *head;  //头指针
    int n;              //链表的真实长度
}Headerlist;

Status Init(Headerlist *l){
    l->head=(node *)malloc(sizeof(node));
    if(!l->head) return 0;   //申请空间失败 
    l->n=0;
    l->head->link=NULL;   
    return 1;
}

//在下标为i+1的位置插入x 
Status Insert(Headerlist *l,int i,ElementType x){
    if(i<-1 ||i>l->n-1) return 0;

    node *q=l->head;
    for(int j=0;j<=i;j++) q=q->link; //q是待插入结点的前驱结点,ai

    node *p;            //生成带插入的结点 
    p=(node *)malloc(sizeof(node ));
    p->value=x; 

    p->link=q->link;
    q->link=p;
    l->n++;
    return 1;
}

Status Output(Headerlist l){
    if(!l.n) return 0;  //空链表
    node *p=l.head->link;
    while(p){
        cout<<p->value<<" ";
        p=p->link;
    } 
    cout<<endl;
    return 1;
}

//带表头链表的逆置
Status Reverse(Headerlist *L){
    node *p,*s,*t;
    p=L->head;
    s=p->link;
    while(s->link){
        t=s->link;
        s->link=p;
        p=s;
        s=t;
    }
    s->link=p;  //处理最后一个结点
    L->head->link->link=NULL; 
    L->head->link=s; 
    return 1;
} 

Status ListSort(Headerlist *l){
    int i=0,j=0;
    node *p,*q;
    node *s=l->head;
    //如果链表是空之间返回
    if(l->n==0 ) return 0;
    //采用冒泡排序 
    for(i=0;i<l->n-1;i++){
        s=l->head->link;
        for(j=0;j<l->n-i-1;j++){
            p=s;
            q=s->link;
            //如果前面的比后面的大,就交换他们之间的数据域
            if(p->value>q->value){
                ElementType temp=p->value;
                p->value=q->value;
                q->value=temp; 
        }
            s=s->link;
        }
    } 
}

int main(){
    int i,x;
    Headerlist list;
    Init(&list);
    for(int i=0;i<9;i++){
        Insert(&list,i-1,i);
    }
    cout<<"The original headerlist is : "<<endl;
    Output(list);
    //逆置 
    Reverse(&list);
    cout<<"After reversion,the heaserlist is: "<<endl;
    Output(list);
    //排序 
    ListSort(&list);
    cout<<"The sorted headerlist is:"<<endl;
    Output(list);
    return 0;
}

5.编写程序实现一元多项式的创建,输出,撤销以及两个一元多项式相加和相乘的操作。

展开阅读全文

没有更多推荐了,返回首页