设计1 线性表的应用

合集下载

C语言——线性表及其应用

C语言——线性表及其应用

C语⾔——线性表及其应⽤程序要求1.建⽴含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2.利⽤前⾯的实验先建⽴⼀个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插⼊元素68。

3.建⽴⼀个带头结点的单链表,结点的值域为整型数据。

要求将⽤户输⼊的数据按尾插⼊法来建⽴相应单链表。

输⼊和输出的格式1.顺序线性表的建⽴、插⼊及删除顺序表#include<stdio.h>#include<stdlib.h>#define ListSize 50typedef int DataType;//线性表的顺序存储⽅式typedef struct {DataType data[ListSize];int l;}SeqList;//创建顺序线性表void CreateList(SeqList *A,int n){int i;for(i=0;i<n;i++){scanf("%d",&(A->data[i]));}A->l=n;}//在顺序线性表中插⼊某个元素void InsertList(SeqList *A,DataType x,int i){int j;if(i<1 || i>A->l) //插⼊时的条件{printf("插⼊位置错误!\n");exit(0);}else{printf("插⼊成功!\n");}if(A->l >= ListSize){printf("列表溢出!\n");exit(0);}for(j=A->l-1;j>=i-1;j--){A->data[j+1]=A->data[j]; //插⼊时,把各个元素向后移动后,然后在进⾏插⼊}A->data[i-1]=x;A->l++;}//在顺序线性表中删除某个元素void DeleteList(SeqList *A,int i){int j;if(A->l==0) //删除时的条件{printf("列表为空!\n");exit(0);}if(i<1 || i>A->l){printf("删除位置错误!\n\n");exit(0);}for(j=i;j<=A->l-1;j++) //删除时,把各个元素向前移动,覆盖掉要删除的元素{A->data[j-1]=A->data[j];}A->l--;}//输出线性表void DisList(SeqList *L){int i;for(i=0;i<L->l;i++)printf("%d ",L->data[i]);printf("\n");}void main(){SeqList *A=(SeqList*)malloc(sizeof(SeqList));int a=7;printf("请输⼊7个整型元素:\n");CreateList(A,a);printf("输出SeqList的长度: \n");printf("长度=%d\n",A->l);printf("表内元素为");DisList(A);DataType x;printf("请输⼊需要插⼊的元素的位置!\n");int i;scanf("%d",&i);printf("请输⼊需要插⼊的元素!\n");scanf("%d",&x);InsertList(A,x,i);printf("长度=%d\n",A->l);printf("表内元素为");DisList(A);printf("请输⼊需要删除的元素的位置!\n");scanf("%d",&i);DeleteList(A,i);printf("表内元素为");DisList(A);printf("长度=%d\n",A->l);}输⼊和输出的格式顺序表输⼊输出:定义输⼊7个整型元素,回车进⾏插⼊和删除,输出线性表2.链式线性表的建⽴、插⼊及删除单链表#include <stdio.h>#include <stdlib.h>typedef int ElemType;//定义结点类型typedef struct Node{ElemType data; //单链表中的数据域struct Node *next; //单链表的指针域}Node,*LinkedList;//单链表的初始化LinkedList LinkedListInit(){Node *A;A = (Node *)malloc(sizeof(Node)); //申请结点空间if(A == NULL) //判断是否有⾜够的内存空间printf("申请内存空间失败\n");A->next = NULL; //将next设置为NULL,初始长度为0的单链表return A;}//单链表的建⽴LinkedList LinkedListCreat(){Node *A;A = (Node *)malloc(sizeof(Node)); //申请头结点空间A->next = NULL; //初始化⼀个空链表Node *r;r = A;ElemType x;while(scanf("%d",&x) != EOF){Node *p;p = (Node *)malloc(sizeof(Node));p->data = x;r->next = p;r = p;}r->next = NULL;return A;}//单链表的插⼊,在链表的第i个位置插⼊x的元素LinkedList LinkedListInsert(LinkedList A,int i,ElemType x){Node *pre; //pre为前驱结点pre = A;int tempi = 0;for (tempi = 1; tempi < i; tempi++)pre = pre->next; //查找第i个位置的前驱结点Node *p; //插⼊的结点为pp = (Node *)malloc(sizeof(Node));p->data = x;p->next = pre->next;pre->next = p;return A;}//单链表的删除,在链表中删除数据值为x的元素LinkedList LinkedListDelete(LinkedList A,ElemType x){Node *p,*pre; //pre为前驱结点,p为查找的结点。

数据结构线性表的基本操作及应用实验报告

数据结构线性表的基本操作及应用实验报告

实验日期2010.4.19 教师签字成绩实验报告【实验名称】第二章线性表的基本操作及应用【实验目的】(1)熟练掌握线性表的基本操作的实现;(2)以线性表的各种操作(建立、插入、删除等)的实现为重点;(3)通过本次实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作)。

【实验内容】1.顺序表的基本操作(顺序表的插入、访问、删除操作)#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType;typedef int Status;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L){int i,n;L->elem = (ElemType * )malloc(LIST_INIT_SIZE*sizeof(ElemType));if (! L->elem) exit (OVERFLOW);printf("您希望您的顺序表有几个元素: ");scanf("%d",&n);printf("\n");printf("输入您的%d个元素,以构建顺序表: \n",n);for(i=1;i<=n;i++)scanf("%d",&L->elem[i-1]);L->length = n;L->listsize = LIST_INIT_SIZE;return OK;}//InitList_SqStatus PrintList_Sq(SqList L){int i;printf("顺序表中的元素为:");for (i=1;i<=L.length;i++)printf("%d ",L.elem[i-1]);printf("\n");return OK;}//PrintList_Sqint ListInsert_Sq(SqList* L,int i,ElemType x) //对顺序表进行插入操作{int j;if (L->length==L->listsize){printf("\t\t\t顺序表已满");return 0;}else{if (i<1||i>L->length){printf("\t\t\t位置不合法");return 0;}else{for(j=L->length-1;j>=i-1;--j)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;L->length++;return 1;}}}int ListDelete_Sq(SqList* L,int i) //对顺序表进行删除操作{int j;if (i<1||i>L->length){printf("\t\t\t不存在第i个元素");return 0;}else{for (j=i-1;j<L->length;j++){L->elem[j]=L->elem[j+1];}L->length--;return 1;}}int LocateElem(SqList *L, int i) {if(i<1||i>L->length)return ERROR;else return L->elem[i-1];}int scan(){int choose;printf("选择要执行的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("输入其他值退出程序……\n");scanf("%d",&choose);return(choose);}void main(){SqList L;ElemType e;int i;int quit=0;if (InitList_Sq(&L)==OVERFLOW)printf("分配失败,退出程序!");printf("输出程序中的元素\n");PrintList_Sq(L);while(!quit)switch(scan()){case 1:printf("\n请输入你所需要插入的位置和你要插入的元素:");printf("\n请输入i和e的值:");scanf("%d%d",&i,&e);if (ListInsert_Sq(&L,i,e)==OK) PrintList_Sq(L);break;case 2:printf("\n请输入你所需要删除元素的位置:");scanf("%d",&i);if(ListDelete_Sq(&L,i)==OK) PrintList_Sq(L);break;case 3:printf("请输入所要查找元素的位置:\n");scanf("%d",&i);if(LocateElem(&L,i))printf("该位置元素的值为:%d!\n",LocateElem(&L,i));else printf("该位置的元素不存在!\n");break;default:quit=1;printf("操作结束!");printf("\n");}}2.单向链表的基本操作(单向链表的插入、删除、查找以及并表操作)#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=NULL;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}void Mergelist_L(LinkList La,LinkList Lb,LinkList Lc) {LNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个单向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ LinkList La,Lb,Lc;int quit=0;int i,locate;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatLinkList();Lb=CreatLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}3.单向循环链表的基本操作(单向链表的插入、删除、查找操作)#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=L;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p==L||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=L;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=L){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}printf("\n");}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}4.双向链表的基本操作(双向链表的插入、删除、查找以及并表操作)#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=NULL;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n");scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=NULL;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p==NULL) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i) {DuLinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i)p=p->next; j++;}if (j==i)return p;else return NULL;}void Mergelist_L(DuLinkList La,DuLinkList Lb,DuLinkList Lc){DuLNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个双向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;DuLinkList L,p;DuLinkList La,Lb,Lc;L=CreatDuLinkList();while(!quit){switch(scan())case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatDuLinkList();Lb=CreatDuLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}5.双向循环链表的基本操作(双向循环链表的插入、删除以及访问操作)#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L; L->prior=L;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=L; L->prior=r;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(j<i){p=p->next;j++;}if(j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向循环链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从双向循环链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p->next==L) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p->next!=L){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i){DuLinkList p;int j=1;p=L->next;while(p->next!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ int quit=0;int i,locate;ElemType e;DuLinkList L,p;L=CreatDuLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}【小结讨论】1.通过实验,我加深了对C的工作环境及其基本操作,进一步掌握了基本函数的调用以及使用方法。

数据结构实验 线性表的应用

数据结构实验 线性表的应用

课程题目:数据结构试验学院:班级:姓名:学号:实验题目:线性表的应用实验内容:分数统计实验目的:掌握线性表的概念及原理,运用线性表的原理完成实验题目中的内容。

实验要求:为了使学生更好的掌握与理解课堂上老师所讲的概念与原理,实验前每个学生要认真预习所做的实验内容及编写源程序代码(写在纸上与盘中均可),以便在实验课中完成老师所布置的实验内容。

实验学时:4学时设计原理:本实验的核心部分为对学生成绩从两个角度进行分析,既对学生的成绩进行了排名、求出学生成绩的平均分和分出学生成绩的数值段。

为了处理学生成绩这些数据,首先必须建立一个新的线性表,新表为空,然后经由input函数程序的执行使得学生的成绩可以输入到计算机中,从键盘输入程序所提示的学生人数后,新线性表的长度得以确定,再通过循环命令语句的调用将全部学生的成绩输入。

输入后,调用output函数处理线性表中的数据,通过调用条件语句和设置变量存储次次数的累加,从而在屏幕上输出各个分数段的人数。

这之后,通过冒泡排序法处理学生成绩这些数据,得出结果后,在调用循环语句命令将结果按顺序输出。

然后再对这些数据进行求平均值的运算,处理后输出。

详细程序清单及注释说明:#include<stdio.h>#include<malloc.h>#define list_init_size 100#define listincrement 10typedef struct{int *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储空间(以sizeof(ElemType)为单位) }sqlist;void initlist_sq(sqlist &l) //创建一个空的线性表{l.elem=(int *)malloc(list_init_size*sizeof(int));l.length=0; //空表长度为0l.listsize=list_init_size; //初始存储容量}void input(sqlist &l){//输入学生的总人数和每个人的成绩int a,b,c;loop1:printf("输入学生人数:");scanf("%d",&b);if(b<=0){printf("输入错误,请重新输入!!\n");goto loop1; //输入错误时,重新输入}printf("\n");l.length=l.length+b; //由输入的值确定线性表的长度for(a=0;a<b;a++){loop:printf("输入第%d名学生的成绩:",a+1);scanf("%d",&c);l.elem[a]=c;if(c<0 || c>100){printf("输入错误,请重新输入!!\n");goto loop; //输入错误时,重新输入}}}void output(sqlist &l){//输出学生的成绩信息printf("\n");int i,a=0,q=0,w=0,e=0,r=0,t=0,y=0;for(i=0;i<l.length;i++){a=l.elem[i]/10;switch(a) //对成绩分段{case 10:q++;break;case 9:w++;break;case 8:e++;break;case 7:r++;break;case 6:t++;break;default:y++;break;}}printf("成绩为100有%d人\n",q);printf("成绩为90~99有%d人\n",w);printf("成绩为80~89有%d人\n",e);printf("成绩为70~79有%d人\n",r);printf("成绩为60~69有%d人\n",t);printf("不及格的有%d人\n\n",y);}void order(sqlist &l){//对成绩进行排序int i,j,k;for(i=0;i<l.length;i++)for(j=0;j<l.length-i;j++)if(l.elem[j]<l.elem[j+1]){k=l.elem[j];l.elem[j]=l.elem[j+1];l.elem[j+1]=k;}printf("经过排序:\n");for(i=0;i<l.length;i++){printf("第%d名成绩为:%d\n",i+1,l.elem[i]);}}void average(sqlist &l){//求出平均成绩int i;float k=0,j=0;for(i=0;i<l.length;i++){j=j+l.elem[i];}k=j/l.length;printf("平均分为:%5.5f\n",k); }void main(){printf("分数统计\n\n");sqlist l;initlist_sq(l);input(l);output(l);order(l);average(l);}运行与测试及结果:在输入错误情况下:试验中所遇到的问题及解决办法:①、实验当中曾经出现数据结果为乱码的现象,后经查找,原因是两个for循环当中的变量i,j顺序颠倒,从而出现了指针没有指向相应的数据结果,而是指向了未知位置的数据。

实验一 线性表的应用

实验一 线性表的应用
voidInitializeVote(VoteTp *vote);
voidInitializeSource(SourceTp *source);
voidSeqInsertVote(VoteTp *vote,inti,ElemTp x);
intSeqLocate(VoteTp v,ElemTp x);
}
}
voidInitializeVote(VoteTp *vote)
{
vote->len=0;
}
voidInitializeSource(SourceTp *Source)
{/*初始化备选数表Source,在表中放入1~3 6共3 6个数,将表长置为36 */
inti;
for(i=1;i<=NN;i++)
#defineMM 7
#defineNN 36
typedefintElemTp;
typedefstruct
{ ElemTp elem[MM+1];
intlen;
} VoteTp;
typedefstruct
{ ElemTp elem[NN+1];
intlen;
} SourceTp;
SourceTp source;
判断中奖情况,就是先初始化猜对号码个数为0,再依次用中奖号码表中的每个号码,在一张彩票号码表中查找,若有,猜对号码个数加1。处理完毕,猜对号码个数即可反映中奖情况。
3.解决方案
(1)彩票号码表、备选数表的存储结构类型定义
#define MM 7/*彩票中号码的个数*/
#define NN 36/*选数的个数*/
备选数表的初始化,备选数表初始状态含有1~36这36个数,元素间的顺序没有意义。

线性表应用实验

线性表应用实验

实验一实验题目:线性表的应用实验内容:分数统计实验目的:掌握线性表的概念及原理,运用线性表的原理完成实验题目中的内容。

实验要求:为了使学生更好的掌握与理解课堂上老师所讲的概念与原理,实验前每个学生要认真预习所做的实验内容及编写源程序代码(写在纸上与盘中均可),以便在实验课中完成老师所布置的实验内容。

设计原理:根据线性表的存储方式,首先定义学生和线性表的存储结构struct student struct sqlist{ {char name[10]; student elme[20];int score; int length;}; };通过添加函数void tianjia(sqlist &l)向线性表l中依次添加数据;数据添加完毕之后通过查找函数void chazhao(sqlist &l)能够依次通过关键字name进行顺序查找,若找到则显示姓名和分数,否则显示没有找到;通过统计函数void tongji(sqlist &l)可以通过关键字score的比较分别统计出各分数段的人数。

程序清单及注释://学生成绩统计.cpp#include<iostream>using namespace std;struct student //学生信息存储结构体{char name[10];//姓名int score;//分数};struct sqlist //线性表存储结构{student elme[20];int length; //线性表长度};//向线性表l中添加数据的函数void tianjia(sqlist &l){//char n[10];int s;cout<<"输入姓名"<<endl;cin>>l.elme[l.length].name;cout<<"请输入分数:"<<endl;cin>>l.elme[l.length].score;cout<<endl;l.length++; //添加一个数据后线性表长度加1cout<<”表长度:”<<l.length<<endl;}//按学生名字为关键字的查找函数void chazhao(sqlist &l){char n[10]; //姓名存储数组int j,s,i,m;s=0;i=0;cout<<"请输入要查找的人的名字:"<<endl;cin>>n;if(l.length!=0)//表长度不为零时从表中查找{for(j=0;j<l.length;j++){for(i=0;l.elme[j].name[i]!='\0';i++){if(l.elme[j].name[i]==n[i]&&l.elme[j].name[i]!='\0') s=1;//s=1表示查找成功else break;}if(s==1) break;}if(s==1) cout<<l.elme[j].score<<endl; //s=1表示查找成功else cout<<"不存在所要查找的对象!"<<endl;}else cout<<"表为空!"<<endl;}//显示函数,将线性表中的数据依次显示出来void xianshi(sqlist &l){int i;for(i=0;i<l.length;i++) //当i小于表长度时进行循环,依次显示每个数据{cout<<l.elme[i].name<<'\t'<<l.elme[i].score<<endl;}}//统计线性表中学生成绩在各个分数段的人数void tongji(sqlist &l){int i,j;int m0=0,m1=0,m2=0,m3=0,m4=0,m5=0,m6=0,m7=0,m8=0,m9=0,M=0;for(i=0;i<l.length;i++){if(l.elme[i].score>=0&&l.elme[i].score<10) m0++;else if(l.elme[i].score>=10&&l.elme[i].score<20) m1++;else if(l.elme[i].score>=20&&l.elme[i].score<30) m2++;else if(l.elme[i].score>=30&&l.elme[i].score<40) m3++;else if(l.elme[i].score>=40&&l.elme[i].score<50) m4++;else if(l.elme[i].score>=50&&l.elme[i].score<60) m5++;else if(l.elme[i].score>=60&&l.elme[i].score<70) m6++;else if(l.elme[i].score>=70&&l.elme[i].score<80) m7++;else if(l.elme[i].score>=80&&l.elme[i].score<90) m8++;else if(l.elme[i].score>=90&&l.elme[i].score<100)m9++;else if(l.elme[i].score=100) M++;}cout<<"10分以下的有"<<m0<<"人"<<endl;cout<<"10~19分的有"<<m1<<"人"<<endl;cout<<"20~29分的有"<<m2<<"人"<<endl;cout<<"30~39分的有"<<m3<<"人"<<endl;cout<<"40~49分的有"<<m4<<"人"<<endl;cout<<"50~59分的有"<<m5<<"人"<<endl;cout<<"60~69分的有"<<m6<<"人"<<endl;cout<<"70~79分的有"<<m7<<"人"<<endl;cout<<"80~89分的有"<<m8<<"人"<<endl;cout<<"90~99分的有"<<m9<<"人"<<endl;cout<<"100分的有"<<M<<"人"<<endl;}//主函数void main(){int i,j=1;sqlist l;l.length=0;while(j==1){cout<<"学生信息统计"<<endl;cout<<"1,添加数据"<<endl;cout<<"2,查找数据"<<endl;cout<<"3,显示数据"<<endl;cout<<"4,统计"<<endl;cout<<"0,退出"<<endl;cout<<"选择所需要的操作:";cin>>i;switch(i){case 1:tianjia(l);break;case 2:chazhao(l);break;case 3:xianshi(l);break;case 4:tongji(l);break;case 0:exit(0);default: {cout<<"ERROR!"<<endl;break;} }}}运行结果:依次添加数据:a 10,b 20,c 30,d 40, e 70查找姓名为e的学生的成绩:显示线性表中的数据:统计各分数段的人数:遇到问题及解决方法:在试验中,由于不清楚对线性表的存储结构刚开始定义不清,没有定义长度,因此查找的时候无法进行,添加上长度后解决;另外对学生信息的存储也不够清晰,还有姓名的存储与显示不够清晰,通过定义学生信息存储结构体解决。

线性表现在建筑外立面设计中的应用

线性表现在建筑外立面设计中的应用

2020·07一、线性表现分类首先想要了解线的艺术概念,就先要从线的整体概念入手。

艺术和数学同属于人文艺术,在此,我们可以参照运用几何学中线条的表现理念。

在几何学中,连续不断的点的移动所形成的轨迹,就形成了线条。

艺术类别中的线条和只有长度没有厚度的几何线条有所不同,在艺术运用中,线条也是可以有厚度和宽度的。

(一)直线建筑造型的基本元素之中,直线是最基础的也是最普遍的线,无论是建筑面的连接、整体的棱还是单体的柱子,檐口、屋门、栏杆、窗格,处处都表现出来一种线性的特征。

直线包括刚硬冷峻的垂直线、亲和舒展的水平线、活泼动感的斜线。

希腊建筑中的柱就是直线的代表,斜线组成的尖角在哥特式建筑中应用甚多。

(二)曲线建筑外立面中也多用到曲线,用这一富含韵律的线性表现可以将建筑的美和灵气体现出来。

带有曲线的飞檐翘脚在我国的传统建筑中就应用广泛,其使建筑在威严庄重间体现祥和高贵。

线性表现中,直线表现一种刚硬的力量感,而曲线有一种柔美的韵律感。

运用中,曲线和直线两者结合,既有层次又有平和。

线条在艺术上的表现力体现为柔美与刚硬的人文性和通过统筹安排变化的规则性。

二、建筑外立面(一)合理性建筑外立面是建筑的外衣,既有美化建筑的作用,又有实用的用途。

合理的设计能够使得建筑艺术感与实用性并存。

比如说在如今的大型建筑设计之中,玻璃幕墙的过多运用就产生了光污染,适当减少并加入绿色设计可以让建筑林立的大都市有更多的生机。

(二)功能多样性在保证建筑外立面的实用性和合理性的前提之下,欣赏性也成为建筑外立面的一个重要功能。

比如:在一个商业街建筑群落里,建筑外立面充满商业元素,视觉冲击力强,信息元素传达力强;而在一个工业建筑群里,建筑外立面充满简洁利索的形式感。

在建筑的不断进展中,艺术的美慢慢融入其中,使得建筑外立面与以前的建筑形式有明显的不同,给人一种耳目一新的感觉。

在保证建筑与周围环境协调发展的同时,艺术的美感不能将建筑外立面的合理性打破,削弱运用功能效果以体现其表面的美感。

线性表的应用(算法与数据结构课程设计)

线性表的应用(算法与数据结构课程设计)

线性表的应用一、问题描述线性表有两种不同的存储结构,分别是顺序存储结构和链式存储结构,在实际中应用十分广泛。

本设计要求分别利用线性表的两种存储结构,设计算法完成对大数的阶乘、加法、乘法的求解。

二、基本要求1、选择合适的存储结构实现大数存储;2、设计算法,采用顺序存储结构完成大数的阶乘运算;3、设计算法,采用链式存储结构完成大数的加法运算;4、设计算法,选择合适的存储结构完成大数的乘法运算;5、其中某一算法采用两种存储结构实现。

三、测试数据1、阶乘运算的测试数据:63!2、加法运算的测试数据: 9876876787+896789675599993、乘法运算的测试数据:9876876787×89678967559999四、算法思想1、阶乘运算的算法思想:一个数的阶乘,利用一个顺序表来存储结果,首先令L.elem[0]=1,其他全部赋值为零,再用for循环,从1至i完成阶乘运算,其中由于位数越乘越多,故将其按位存储在顺序表中,防止数据范围溢出,在逐位相乘中,利用for循环位数,如若有进位问题,每次运算时,此位保留的数位,t=L.elem[j]*i+jw; L.elem[j]=t%10;jw=t/10;如果满足j>=top && jw==0;程序跳出,进行下一步i运算,此处top位保留上一位的位数,如此运算下去,输出顺序表。

2、加法运算的算法思想:本运算分别采用了两种存储结构,链式和栈存储结构。

加法是两个数位数对齐,从低位向高位加的运算,如果在哪位有进位,则后一位,进行加法还要另加上前面的进位,由此将输入的字符大数,存入链表中,且改为整形存入,此时是的链表是倒序的,定义一个变量表示每次的进位jw=0,建立一个链表,让他存储结果,如此两链表的数相加,每次还要加上上次留下的进位,此为保留的数位:new->data =(p->data +q->data +jw)%10; new->next =NULL;jw =(p->data+q->data+jw)/10;当两个数是一场一短时,自然当相等的长度加完后在执行下面的判断,保留住剩下的数同时每次加上jw,最后就是当最后一位有进位时将最后一个链表值赋jw,由于现在此链表存储的结果是反序的,故将其压入栈中,让后再输出栈元素,就是想加的结果。

“线性表及其应用”实验报告

“线性表及其应用”实验报告

序号73 学号2013112000 姓名张三实验 2 实验名称线性表及其应用难度等级B+一、需求分析1、问题描述设计一个一元稀疏多项式简单计算器.2、基本要求一元稀疏多项式基本功能包括:1)输入并建立多项式⏹一元n次多项式:P n(x)=c m错误!未找到引用源。

+c m-1错误!未找到引用源。

+…+c1错误!未找到引用源。

,其中n=e m>e m-1>…>e1≥0,c i≠0(i=1,2,m)⏹输入(c m,e m)(c m-1,e m-1)…(c1,e1)构建一元n次m项多项式2)输出多项式:c m x^e m+c m-1x^e m-1+…+c1x^e13)多项式a和b相加,建立a+b4)多项式a和b相减,建立a-b3、测试数据1)(-3.1x11+5x8+2x)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后多项式.二、概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作:createPoly(&p,m,(*input)())Result: 指数由大到小输入m项的系数和指数,建立一元多项式pdestroyPoly(&p)Condition: 一元多项式p已存在Result: 销毁一元多项式ptraversePoly(p)Result: 输出一元多项式addPoly(&pa,&pb);Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.subtractPoly(&pa,&pb)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial三、详细设计1、 数据类型定义typedef struct{float coef; int expn;}ElemType;//定义存放多项式中项的系数和指数 typedef struct LNode{ElemType data;struct LNode *next; }LNode, *LNodePtr;定义单链表的数据类型 typedef struct{LNodePtr hp; int length;}LinkList;创建单链表typedef LinkList Poly;//将链表定义为多项式类型 2、 函数原型定义Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)); Status traversePoly(Poly p, Status (*visit)(int, int, float, int)); Status destroyPoly(Poly &p);Status addPoly(Poly &pa, Poly &pb);//下面的函数可以根据需要由用户在main()函数中定义 Status input(int, float *, int *); Status visit(int, int, float, int);3、 核心算法描述⏹ createPoly()Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)){ int i,expn; float coef; LNodePtr s,hp;p.hp =(LNodePtr)malloc(sizeof(LNode)); if(!p.hp) exit(OVERFLOW); p.hp->next=NULL; p.length=0; hp=p.hp;for(i=1;i<=m;i++){(*input)(i,&coef,&expn);s=(LNodePtr)malloc(sizeof(LNode)); if(!s) exit(OVERFLOW); s->data.coef=coef; s->data.expn=expn; s->next=NULL; hp->next=s; hp=s; }p.length=m; return OK; }⏹ traversePoly()Status traversePoly(Poly p, Status (*visit)(int,int, float, int)){ int m;LNodePtr q;构建链表头结点,完成链表初始化 根据用户输入多项式的项信息构建多项式,hp 指向当前创建结点q=p.hp->next;for(m=1;m<=p.length;m++){(*visit)(p.length,m,q->data.coef,q->data.expn);q=q->next;}return OK;}⏹destroyPoly()Status destroyPoly(Poly &p){LNodePtr q;while(p.hp){q=p.hp;p.hp=q->next;free(q);}p.length=0;return OK;}⏹addPoly()Status addPoly(Poly &pa, Poly &pb){LNodePtr q,ap,bh,bp,s;float tcoef;int result;q=pa.hp; ap=q->next; bh=pb.hp; bp=bh->next;while(ap&&bp){result=ap->data.expn-bp->data.expn;if(result<0){s=bp; bp=bp->next; bh->next=bp;q->next=s; s->next=ap; q=s;pa.length++; pb.length--;}else if(result>0){q=ap; ap=ap->next;}else{tcoef=ap->data.coef+bp->data.coef;if(!tcoef){q->next=ap->next; free(ap);ap=q->next;pa.length--;}else{ap->data.coef=tcoef; q=ap;ap=ap->next;}bh->next=bp->next; free(bp);bp=bh->next; pb.length--;}//result=0}//while 根据用户定义的输出函数遍历多项式的每一项并将项和系数输出if(bp) {q->next=bp; pa.length += pb.length; bh->next=NULL; pb.length=0;}free(pb.hp);return OK;}4、函数调用关系main()首先调用createPoly(),traversePoly(),addPoly(),而createPoly()调用用户自定义input()输入多项式信息,traverPoly()调用用户自定义visit()输出多项式信息.四、运行记录测试数据预期结果实际结果分析(-3.1,11) (5,8) (2,1) -3.1x^11+5x^8+2^x -3.1x^11-3.1x^11-3.1x^11 scanf(“(%f,%d)”)(-3.1,11)(5,8)(2,1) -3.1x^11+5x^8+2^x -3.1x^11+5.0x^8+2.0x^1 剔除输入数据项括号之间的空格测试addPoly()pa:(-3.1,11)(5,8)(2,1) pb:(11,9)(-5,8)(7,0) -3.1x^11+11x^9+2x^1+7-3.1x^11+11x^9+2x^1原因算法中忽略了对pa和pb长度的处理,另外,在将剩余元素加到pa上,忘记对pb头结点的处理即pb.hp->next=NULL五、总结这次实验的难度和复杂度高于第一次实验,第一次实验是熟悉C语言环境,本次实验要求对结构体、链表和多项式项的特点要熟练掌握。

数据结构实验报告(一)线性表的应用

数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。

⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。

要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。

2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。

要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。

如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。

(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。

(3)当给定x的值时,能计算表达式相加或相减的结果。

(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。

(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。

实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。

2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。

(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。

因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。

综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。

3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。

实验一 线性表的基本操作实现及其应用

实验一 线性表的基本操作实现及其应用

实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。

2、会用线性链表解决简单的实际问题。

二、实验内容题目一、该程序的功能是实现单链表的定义和操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。

单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。

其中黑体部分必做题目二、约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,每个人持有一个正整数密码。

开始时任选一个正整数做为报数上限m,从第一个人开始顺时针方向自1起顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数。

如此下去,直到所有人全部出列为止。

令n最大值取30。

要求设计一个程序模拟此过程,求出出列编号序列。

struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};三、实验步骤(一)数据结构与核心算法的设计描述1、单链表的结点类型定义/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 定义DataType,status为int类型 */typedef int DataType;typedef int status;/* 单链表的结点类型 */typedef struct LNode{DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit(){ //定义并返回头结点L}3、清空单链表void LinkedListClear(LinkedList L){// L是带头结点的链表的头指针,释放除头结点外的所有内存空间}4.检查单链表是否为空int LinkedListEmpty(LinkedList L){//L是带头结点的链表的头指针,判断头结点的next是否为空,如果空//返回OK,否则返回ERROR}5、遍历单链表void LinkedListTraverse(LinkedList L){// L是带头结点的链表的头指针,遍历并输出L所有结点(不包括头//结点)的数据}6、求单链表的长度int LinkedListLength(LinkedList L){//L是带头结点的链表的头指针,通过遍历链表用i记录结点个数(不//包括头结点),并返回i}7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){//L是带头结点的链表的头指针,返回第 i 个元素}8、从单链表表中查找与给定元素值相同的元素在链表中的位置(位置)int LinkedListGet1(LinkedList L,DataType x){//L是带头结点的链表的头指针,返回值为x元素在链表中的位置的//位置9、从单链表表中查找与给定元素值相同的元素在链表中的位置(指针)LinkedList LinkedListLocate(LinkedList L, DataType x){//L是带头结点的链表的头指针,返回值为x元素的指针}10、向单链表中插入元素status LinkedListInsert(LinkedList L,int i,DataType x){}(二)函数调用及主函数设计图1.主函数流程图(三)程序调试及运行结果分析1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(四)实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。

线性表及其应用实验报告

线性表及其应用实验报告
void InitList_Sq(SqList *sq) //初始化列表
{
sq->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
sq->length=0;
sq->listsize=LIST_INIT_SIZE;
printf("---申请空间成功---!\n");
实验报告册
课 程:《数据结构》
***********
学 号:*********
专 业:网络工程
班 级:10级网络工程
*******************
2011至2012学年第一学期
洛阳师范学院
信 息 技 术 学 院
实验时间:9月30日3、4节 星期五
实验地点:一号教学楼微机室
实验名称:线性表及其应用
}
刚开始设计时,没有加入这段程序,结果导致整个程序不够健壮。在设计后期,发现了这个问题,就尝试着进行编译,经过不断的编译调试,最后程序可以运行了,尽管依然不够完美。
经过这次实验,能够全面考虑问题了,意识到了程序的健壮性,不只是以程序能否运行为目标环境:微机室、 DEV-C++
实验步骤:1、确定基本思路和设计思想
2、确定程序主题
3、进行编程设计
4、调试程序
5、分析程序错误,编译调试
6、总结经验
实验体会:对程序设计一直讳莫如深,刚接触数据结构,觉得好难,接触一段时间之后,觉得果然如此。编程一直是我的弱项,调试这个程序却是费了不少心力。如:

实验一线性表应用

实验一线性表应用

数据结构
实验题目
5.复数四则运算 问题描述 设计一个简单的复数四则运算计算器。 实验要求 1)采用顺序表或链表等数据结构。 2)输入并生成复数。 3)输出运算结果的标准复数形式。
数据结构
实验题目
6.三元组长整数运算 问题描述 设计一个长整数运算计算器。 实验要求 1)采用顺序表或链表定义的三元组数据结构。 2)输入并生成长整数。 3)完成定义的长整数的加减运算。
数据结构实验
LOGO
Hale Waihona Puke 数据结构实验一实验题目
线性表应用
1.运动会竞赛成绩统计 问题描述 东北大学第51届运动大会成功举行。共有N个学院的 男女代表队参赛。大会共设M个男子项目和W个女子 项目。大会即将闭幕,准备公布成绩。
数据结构 实验题目
1.运动会竞赛成绩统计 实验要求
设计运动会竞赛成绩统计程序。 1)采用表或链表等数据结构。 2)统计各代表队的男女总分和团体总分。 3)公布各单项成绩的前六名和团体成绩的前三名。 4)可以查询成绩。
数据结构
实验题目
2.约瑟夫环问题 实验要求 设计求解Josephus排列问题程序。 1)采用顺序表、单链表或双向循环链表等数据结构。 2)采用双向循环链表实现Josephus排列问题,且奇数 次顺时针轮转,偶数次逆时针轮转。 3)推荐采用静态链表实现Josephus排列问题。
数据结构
实验题目
数据结构
实验题目
10.元素整体互换 问题描述 对线性表中的前M个元素和后N个元素整体互换。 实验要求 设计元素整体互换的模拟程序。 1)采用顺序表存储结构实现。 两种 2)采用链表存储结构实现。一种 3)分别采用低效和高效两种算法实现。
数据结构
实验题目

数据结构实验一_线性表的应用

数据结构实验一_线性表的应用
*(p+1) = *p;
*q = a;
++L.length;
}
//*************以下为删除元素部分*********************
void delete(){
int i, a, b;
int *p, *q;
printf("请输入删除的位置:\n");
scanf("%d", &a);


#include<stdio.h>
#include<stdlib.h>
#define max_list_size 100//定义给顺序表分配空间大小
typedef struct{
int *elem;
int length;
}list_node;//指向顺序表首地址的结构体单元
list_node L;//这里使用了全局变量,意思是在所有的函数里可以随意修改其值
{Elemdata[MAXSIZE]; /*存放线性表的数组*/
int length; /*length是顺序表的长度*/
}SeqList;
/*初始化顺序表*/
SeqList SeqListInit( )
*检查顺序表是否为空*/
int ListEmpty(SeqList L)
/*遍历顺序表*/
void ListTraverse(SeqList L)
/*从顺序表中查找元素*/
DataType ListGet(SeqList L ,int i)
/*向顺序表中插入元素*/
voidListInsert(SeqList L,int i,DataType x)

实验一线性表应用---多项式计算分析解析

实验一线性表应用---多项式计算分析解析

浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验一线性表应用---多项式计算实验成绩指导老师(签名)日期一.实验目的和要求1.进一步掌握线性表的的基本操作。

2.掌握线性表的典型应用----多项式表示与计算。

二. 实验内容1.设用线性表( (a1, e1), (a2, e2), ……, (am, em) ) 表示多项式P(x) = a1*x e1 + a2*x e2+…+ am*x em,其中:a1~am为非零系数,0≤e1<e2<…..<em,请编写用链式存储结构(带表头附加结点的单链表)存储该多项式时,多项式基本操作的实现函数。

多项式基本操作应包括初始化多项式、清除多项式、输出多项式、插入一项、删除一项、多项式求值、多项式相加等。

要求:把多项式线性表的结构定义及多项式基本操作实现函数存放在头文件Linkpoly.h中,主函数存放在主文件test6_1.cpp中,在主函数中通过调用Linkpoly.h中的函数进行测试。

2.选做:编写用顺序存储结构存储多项式时,多项式基本操作的实现函数。

要求:把多项式线性表的结构定义及多项式基本操作实现函数存放在文件Seqpoly.h中,在主文件test6_1.cpp中增加测试语句对Seqpoly.h中的函数进行测试。

3.填写实验报告,实验报告文件取名为report1.doc。

4.上传实验报告文件report1.doc与源程序文件test6_1.cpp及Linkpoly.h、Seqpoly.h(若有)到Ftp服务器上自己的文件夹下。

三. 函数的功能说明及算法思路typedef struct{double coef;int exp;}ElemType;typedef struct Node{ElemType data;struct Node *next;}LNode;//初始化多项式void InitPoly(LNode *&H)//清除多项式void ClearPoly(LNode *&H)//输出多项式void TraversePoly(LNode *H)//插入一项多项式bool InsertPoly(LNode *H,int pos,double a,int e) {if(pos==0) //按指数有序插入{……}else //按pos值插入{……}}//删除一项多项式bool DeletePoly(LNode* H,int pos,double &a, int &e) {if(pos==0) //按系数或指数删除{……}else //按pos值删除{……}}//多项式求值double PolySum(LNode *H,double x)//多项式相加LNode *PolyAdd(LNode *a,LNode *b){while(pa!=a&&pb!=b)//当两个表同时不为空时{if(pa->data.exp==pb->data.exp){if((v=pa->data.coef+pb->data.coef)!=0){……}}else if(pa->data.exp<pb->data.exp)//将pa所指结点插入c链表{}else//将pb所指结点插入c链表{}}while(pa!=a)//将a链表中剩余结点复制到c链表{}while(pb!=b) //将b链表中剩余结点复制到c链表{}}四. 实验结果与分析五. 心得体会【附录----源程序】test6_1.cpp#include<stdio.h>#include<iostream.h> #include<stdlib.h> typedef struct{double coef;int exp;}ElemType;typedef struct Node{ ElemType data;struct Node *next; }LNode;#include"LinkPoly.h"void main(){LNode *a,*b,*c;//初始化InitPoly(a);InitPoly(b);ElemType ra[4]={{5,0},{3,2},{-6,3},{2,5}};ElemType rb[6]={{3,0},{4,1},{-2,2},{3,3},{-2,5},{9,6}};int i;for(i=3;i>=0;i--)InsertPoly(a,1,ra[i].coef,ra[i].exp);for(i=5;i>=0;i--)InsertPoly(b,1,rb[i].coef,rb[i].exp);//遍历cout<<"Poly_A(x)=";TraversePoly(a);cout<<endl;cout<<"Poly_B(x)=";TraversePoly(b);cout<<endl;//求和cout<<"多项式Poly_A与多项式Poly_B相加得:"<<endl;c=PolyAdd(a,b);cout<<"Poly_C(x)=";TraversePoly(c);cout<<endl;int pos;char u,v,w;ElemType T;//插入cout<<"按指数有序插入一项多项式:"<<endl;cout<<"请输入待插入项:";cin>>u>>T.coef>>v>>T.exp>>w;if(InsertPoly(c,0,T.coef,T.exp)){cout<<endl<<"插入后,多项式Poly_C为:"<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"按pos值插入一项多项式:"<<endl;cout<<"请输入pos值:";cin>>pos;cout<<"请输入待插入项:";cin>>u>>T.coef>>v>>T.exp>>w;if(InsertPoly(c,pos,T.coef,T.exp)){cout<<endl<<"插入后,多项式Poly_C为:"<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;//删除cout<<"请输入待删除项的pos值:";cin>>pos;if(DeletePoly(c,pos,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后,多项式Poly_C为:"<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"请输入待删除项的系数:";cin>>T.coef;if(DeletePoly(c,0,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后,多项式Poly_C为:"<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"请输入待删除项的指数:";cin>>T.exp;if(DeletePoly(c,0,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后,多项式Poly_C为:"<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;//求值double x;cout<<"请输入待求值的x:";cin>>x;cout<<"Poly_C(x)="<<PolySum(c,x)<<endl<<endl;//清除ClearPoly(a);ClearPoly(b);ClearPoly(c);}Linkpoly.h//初始化多项式void InitPoly(LNode *&H){if((H=new LNode)==NULL)exit(0);H->next=H;}//清除多项式void ClearPoly(LNode *&H){LNode *cp=H->next;LNode *np;while(cp!=H){np=cp->next;delete cp;cp=np;}H->next=H;}//输出多项式void TraversePoly(LNode *H){LNode *p=H->next;if(p!=H){cout<<p->data.coef<<'x'<<'^'<<p->data.exp;p=p->next;while(p!=H){if(p->data.coef>0)cout<<'+';cout<<p->data.coef<<'x'<<'^'<<p->data.exp;p=p->next;}}cout<<endl;}//插入一项多项式bool InsertPoly(LNode *H,int pos,double a,int e){LNode *newptr;if((newptr=new LNode)==NULL)return false;newptr->data.coef=a;newptr->data.exp=e;LNode *cp=H->next;LNode *ap=H;if(pos==0){while(cp!=H){if(e>ap->data.exp&&e<cp->data.exp)break;else if(e==cp->data.exp){cp->data.coef+=a;return true;}else{ap=cp;cp=cp->next;}}newptr->next=cp;ap->next=newptr;}else{int i=0;while(cp!=H){i++;if(i==pos)break;else{ap=cp;cp=cp->next;}}if(cp==H&&i+1<pos){cout<<"pos值无效!"<<endl;return false;}newptr->next=cp;ap->next=newptr;}return true;}//删除一项多项式bool DeletePoly(LNode* H,int pos,double &a, int &e) {if(H->next==H)return false;LNode *cp=H->next;LNode *ap=H;if(pos==0){while(cp!=H){if(a==cp->data.coef||e==cp->data.exp)break;else{ap=cp;cp=cp->next;}}if(cp==H){cout<<"不存在符合条件的项!"<<endl;return false;}}else{int i=0;while(cp!=H){i++;if(i==pos)break;else{ap=cp;cp=cp->next;}}if(cp==H){cout<<"pos值无效!"<<endl;return false;}}a=cp->data.coef;e=cp->data.exp;ap->next=cp->next;delete cp;return true;}//多项式求值double PolySum(LNode *H,double x){int i=0;double sum=0,w=1;LNode *p=H->next;while(p!=H){while(i<p->data.exp){w*=x;i++;}sum+=p->data.coef*w;p=p->next;}return sum;}//多项式相加LNode *PolyAdd(LNode *a,LNode *b){double v;LNode *c;InitPoly(c);LNode *pc=c,*pa=a->next,*pb=b->next;while(pa!=a&&pb!=b){if(pa->data.exp==pb->data.exp){if((v=pa->data.coef+pb->data.coef)!=0){InsertPoly(pc,1,v,pa->data.exp);pc=pc->next;}pa=pa->next;pb=pb->next;}else if(pa->data.exp<pb->data.exp){InsertPoly(pc,1,pa->data.coef,pa->data.exp);pc=pc->next;pa=pa->next;}else{InsertPoly(pc,1,pb->data.coef,pb->data.exp);pc=pc->next;pb=pb->next;}}while(pa!=a){InsertPoly(pc,1,pa->data.coef,pa->data.exp);pc=pc->next;pa=pa->next;}while(pb!=b){InsertPoly(pc,1,pb->data.coef,pb->data.exp);pc=pc->next;pb=pb->next;}return c;}。

线性表的应用举例

线性表的应用举例

position=people.head;
//让position指向最后一个结点,以便报数从第一 个开始
while (position->next!=people.head)
position= NextElem(people,position); scanf(“%d”,&m); //输入最初的m
的结点
if (InitList(&people)==ERROR) exit ERROR; //初始化链表people
for (i=1;i<=n;i++) //以n个人的信息为数据域 内容向链表插入n个结点
if (ListInsert(&people,i,code[i-1])==ERROR) exit ERROR;
position=0;
//记录当前报数人的编号
count=0;
//记录当前所报的数目
for (i=1;i<=n;i++)
{
do{
//报数
position=(position+1)%n;
GetElem(people,position,&temp);
if (temp>0) count++;
}while (count!=m);
printf(“%d”,position);
//输出当前离开桌旁人的编号
GetElem(people,position,&m);
people.item[position-1]=people.item[position-1];

//将密码变为负值
}
}
链式存储结构
使用一个不带头结点的循环单链表结构。结点结

数据结构(Java版)线性表的实现和应用[完整版]

数据结构(Java版)线性表的实现和应用[完整版]

实验报告
课程名称数据结构
实验项目线性表的实现及应用
实验仪器PC机一台
学院_____ 专业
班级/学号
姓名
实验日期
成绩
指导教师
北京信息科技大学
信息管理学院
(数据结构课程上机)实验报告
3.
1.实验名称、实验目的、实验内容、实验要求由教师确定,实验前由教师事先填好,然后作为实验报告模
版供学生使用;
2.实验准备由学生在实验或上机之前填写,教师应该在实验前检查;
3.实验过程由学生记录实验的过程,包括操作过程、遇到哪些问题以及如何解决等;
4.实验总结由学生在实验后填写,总结本次实验的收获、未解决的问题以及体会和建议等;
5.源程序、代码、具体语句等,若表格空间不足时可作为附录另外附页。

线性表应用举例

线性表应用举例

}
-
D.S.数据结构
第2章 线性表
按正位序创建一个不带表头结点的单链表
1、创建 p=(Linklist)malloc(sizeof(LNode)); scanf("%c",&p->data); L=p;q=p;
//2第、一打个印结点 p=L;
for(i=2;i<=n;i++)
/3/其、余测结试点
{ p=(Linklist)malloc(sizeof(LNode)); L=NULL;
}
-
D.S.数据结构
第2章 线性表
2、建立源程序文件测试:ceshi.c
#include "linkh.h" /*文件包含*/
main() { Linklist L;
clrscr(); L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; create_L(L); print_L(L); Insert_x_y(L); print_L(L); }
scanf("%c",&p->data); p->next=NULL; q->next=p;q=p; } }
-
D.S.数据结构
第2章 线性表
void print_L(Linklist L) { Linklist p;
printf("The list is:\n"); p=L->next; while(p) { printf("%3c",p->data);
-
D.S.数据结构
第2章 线性表
1、建立头文件:linkh.h

线性表的应用原理

线性表的应用原理

线性表的应用原理1. 什么是线性表线性表是一种具有相同数据结构和相同数据属性的数据序列,即数据元素之间呈线性关系。

线性表中的数据元素按照线性的顺序存储,每个元素只有一个直接前驱和一个直接后继。

2. 线性表的基本操作线性表常见的基本操作包括: - 初始化线性表:创建一个空的线性表 - 插入操作:在指定位置插入一个元素 - 删除操作:删除指定位置的元素 - 查找操作:根据元素值或位置查找元素 - 修改操作:修改指定位置的元素 - 获取表长度:获取线性表中的元素个数3. 线性表的应用场景线性表的应用非常广泛,以下是几个常见的应用场景:3.1 通讯录管理通讯录是一个常见的线性表应用。

可以用线性表来管理联系人的信息,每个联系人作为线性表的一个元素,包含姓名、电话号码、地址等属性。

通过线性表的基本操作,可以实现添加新联系人、删除联系人、查找联系人等功能。

3.2 缓存替换算法在操作系统或数据库管理系统中,缓存替换算法采用线性表结构来实现。

常见的缓存替换算法如最近最少使用算法(LRU)和先进先出算法(FIFO)。

线性表结构可以便于对缓存中的数据进行插入、删除和查找操作。

3.3 任务调度线性表可以用于任务调度系统中,将需要执行的任务按照一定的优先级顺序存储在线性表中。

调度程序可以根据任务的优先级从线性表中选择下一个要执行的任务,并进行相应的调度操作。

3.4 图形学中的顶点表在计算机图形学中,顶点表用于存储图形模型的顶点信息。

顶点表是一个线性表,每个元素表示一个顶点,包含三维坐标和顶点颜色等属性。

通过线性表的基本操作,可以对顶点表进行插入、删除、查找和修改操作,实现图形模型的编辑和渲染。

3.5 公交线路查询系统公交线路查询系统中,线路信息可以用线性表来存储。

每个线路作为线性表的一个元素,包含站点序号、站点名称、所属线路等属性。

通过线性表的基本操作,可以实现线路的添加、删除、查找和修改,方便用户查询公交线路信息。

4. 总结线性表作为一种基本的数据结构,具有广泛的应用场景。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

设计1 线性表的应用
实验目的:
1.掌握调试线性表的基本方法;
2.掌握线性表的一些基本操作;
3.加深理解线性表并进行实际应用;
项目1:有序表合并
实验内容:
将两个有序链表合并为一个有序链表
设计要求:
实现以下函数。

1.基本操作
Linklist creat()
操作结果:构造一个链表,并输入数据,返回头节点指针。

void prin t(Linklist head)
初始条件:链表已存在;
操作结果:将链表输出。

void MergeList_1(Linklist La, Linklist Lb)
初始条件:有序线性链表La和Lb已存在;
操作结果:将La和Lb两个链表按从小到大的顺序合并。

void MergeList_2(Linklist La, Linklist Lb)
初始条件:有序线性链表La和Lb已存在;
操作结果:将La和Lb两个链表按从大到小的顺序合并。

2. 编写主函数,调用上述基本操作,实现将两个有序链表合并为一个有序链表。

3. 提交实验报告
#include<stdio.h>
#include<stdlib.h>
typedef struct Node{/*定义结构体*/
int data;/*定义一个int型的数据*/
struct Node * next;/*next*/
}*LinkList;/*给Node重命名为LinkList*/
struct Node *Creat(int n){ /*单链表创建函数的定义*/
LinkList p1,p2,head;
int s;
head=NULL;
printf("请输入单链表数据:\n");
for(int i=0;i<n;i++)
{
printf("第%d个数据:",i+1);
p1=(LinkList)malloc(sizeof(struct Node));
scanf("%d",&s);
p1->data=s;
if(head==NULL)
head=p1;
else
p2->next=p1;
p2=p1;
}
p1->next=NULL;
return head;
}
void Print(LinkList h)/*单链表输出函数的定义*/
{
printf("输出:\n");
while(h!=NULL){
printf("%d ",h->data);
h=h->next;
}
printf("\n");
getchar();
}
LinkList MergeList(LinkList LA,LinkList LB) //合并两个单链表函数的定义{
Node *pa,*pb;
LinkList LC,r;//将LC初始置空位
pa=LA->next;//pa指向单链表LA的第一个结点
pb=LB->next;//pb指向单链表LB的第一个结点
LC=LA;
LC->next=NULL;
r=LC;//r初始值为LC,且r始终指向LC的表尾
while(pa!=NULL&&pb!=NULL)
{
if(pa->data<=pb->data)
{
r->next=pa;
r=pa;
pa=pa->next;
}
else
{
r->next=pb;
r=pb;
pb=pb->next;
}
}
if(pa)//若表LA未完,将表LA中后续元素链接到新表LC表尾r->next=pa;
else//否则将表LB中后续元素链接到新表LC表尾
r->next=pb;
free(LB);
return(LC);
}
int main()
{
LinkList L1,L2,L3;
int n1,n2;
printf("请输入两个链表节点数:\n");
scanf("%d %d",&n1,&n2);//获取两个单链表的结点数
L1=Creat(n1);//调用单链表生成函数
L2=Creat(n2);//同上
L3=MergeList(L1,L2);//调用单链表合并函数
Print(L3);//调用输出函数
return 0;
}
项目2: 一元多项式的表示及相加
一、实现内容
1)建立单向链表,存放一元多项式,并输出该多项式;
2)求两个一元多项式相加之和;
二、设计要求:
1、定义多项式结点:
a i x i*/
/* 一元多项式:a0+a1x+a2x2+…+a n x n=
i=0,1,…,n
struct Polynode
{
*/
float coef; /* 系数:a
i
int exp ; /* 指数: i */
struct Polynode *next; /* 指向下个结点的指针*/ };
typedef struct Polynode POLY; /* 类型名*/
2、编写下列函数:
函数PolyCreat
●原型:POLY*PolyCreat ( );
●功能:建立单向链表,返回一元多项式链表的头指针
●说明:每个单向链表至少输入3个多项式项结点,输入的系数和指数皆为0时表示表
达式结束;每个结点按指数递增顺序排列,如:多项式2x2-3x3+4x5-x7,其单向链表
表示如下:
输入应为:2, 2 -3, 3 4, 5 -1, 7 0, 0
函数PolyPrt
●原型:void PolyPrt(POLY *lhead);lhead是单向链表头指针
●功能:以(系数,指数)的形式输出单向链表,如表达式为:
2x2 -3x3+4x5-x7
则应输出:
(2,2)(-3,3)(-4,5)(-1,7)
函数PolyAdd
●原型:void PolyAdd (POLY *heada, POLY *headb);heada、headb分别为两个一元多
项式的头指针
●功能:将两个多项式相加,并把“和”存放在多项式链表heada中,且将多项式链表
headb删除
主函数:
调用PolyCreat ( ) 生成一个一元多项式
调用PolyPrt输出多项式,形式为:(系数,指数)序列
调用PolyCreat ( ) 生成另一个一元多项式
调用PolyPrt输出第二个多项式
调用PolyAdd实现两个多项式相加
调用PolyPrt输出两个多项式之和
是否继续?
三、思考题:
a)一元多项式的相加能否用数组的方式实现?分析数组和链表分别适用于什么样的多项式?
b)函数PolyCreat ( )的返回值可否不定义成指针类型?为什么?
c)*如果多项式的指数大小任意输入,能否通过修改程序实现多项式指数由低到高?
d)*如果需要输出多项式的值(对给定的x),程序应如何修改?
项目3:通讯录管理
实验内容:
实现通讯录管理的插入、删除、查询、输出等功能。

菜单:
设计要求:
实验报告样式。

相关文档
最新文档