线性表及其应用
数据结构线性表的基本操作及应用实验报告
实验日期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的工作环境及其基本操作，进一步掌握了基本函数的调用以及使用方法。
实验1线性表及其应用实验报告
实验1线性表及其应⽤实验报告暨南⼤学本科实验报告专⽤纸课程名称数据结构成绩评定实验项⽬名称线性表及其应⽤指导教师王晓明实验项⽬编号实验⼀实验项⽬类型综合性实验地点南海楼601 学⽣姓名朱芷漫学号2010051875学院信息科学技术学院系计算机专业计算机科学与技术实验时间2011年9⽉7⽇18:30午～9⽉7⽇20:30午温度℃湿度⼀、实验⽬的和要求实验⽬的：熟练掌握线性表基本操作的实现及应⽤实验要求：在上机前写出全部源程序完毕并调试完毕。
⼆、实验原理和主要内容1.建⽴4个元素的顺序表SqList={2，3，4，5}，实现顺序表的基本操作；在SqList={2,3,4,5}的元素4与5之间插⼊⼀个元素9，实现顺序表插⼊的基本操作；在SqList={2,3,4,9,5}中删除指定位置(i=3)上的元素，实现顺序表删除的操作。
2.利⽤顺序表完成⼀个班级的⼀个学期的课程的管理：能够增加、删除、修改学⽣的成绩记录。
三、主要仪器设备PC机，Windows XP操作平台，Visual C++四、调试分析学⽣课程管理系统的调试过程中发现⼀些错误，主要是参数设置的问题，经过修改，错误得到排除。
五、测试结果1.顺序表2.学⽣课程管理系统附录（源程序）1.顺序表的操作#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2 typedef struct shunxubiao{ElemType *list;int size;int Maxsize;}SqList;int InitList_Sq(SqList &L) {// 构造⼀个空的线性表L。
实验一 线性表的基本操作实现及其应用
实验一线性表的基本操作实现及其应用一、实验目的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(一)1．进入选择界面后，先选择7，进行插入：2.选择4，进行遍历，结果为：3.选择2，得出当前链表长度.4.选择3，得出当前链表为.5.选择分别选择5、6进行测试.6.选择8，分别按位置和元素值删除.7.选择9，或非1-8的字符，程序结束.(二) 实验总结通过这次实验，我对线性链表有了更深的理解，深入明白了线性存储结构与链式存储结构在内存存储的不同特点，同时我还学会了用这些知识实际解决一些问题，能够更加熟练地将算法转化为实际程序。
同时，在写程序和调试程序的过程中，学会了一些书写技巧和调试技巧，这对于自己能在短时间高效的写出正确地程序有很大作用。
四、主要算法流程图及程序清单 1. 主要算法流程图：(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数，传入参数L ，xp=L->next2.程序清单：#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为："<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空！"<<endl;}else{cout<<"\t\t\t链表为空！"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i：";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为："<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度！"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值：";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为："<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为："<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在！"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值：";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置：";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功！"<<endl;}else{cout<<"\t\t\t插入失败！"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择：";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置：";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素：";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除！"<<endl;}else{cout<<"\t\t\t删除失败！"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题，可以先定义一个长度为30（人数）的数组作为线性存储结构，并把该数组看成是一个首尾相接的环形结构，那么每次报m的人，就要在该数组的相应位置做一个删除标记，该单元以后就不再作为计数单元。
数据结构 线性表
第1讲线性表本章主要掌握如下内容：线性表的定义和基本操作，线性表的实现,线性表的顺序存储结构及链式存储结构，线性表的应用。
知识点分析（一）线性表的定义和基本操作1．线性表基本概念1）定义：是由相同类型的结点组成的有限序列。
如：由n个结点组成的线性表（a1, a2, …, a n）a1是最前结点，a n是最后结点。
结点也称为数据元素或者记录。
2）线性表的长度：线性表中结点的个数称为其长度。
长度为0的线性表称为空表。
3）结点之间的关系：设线性表记为（a1,a2,…a i-1 , a i, a i+1 ,…a n），称a i-1是a i的直接前驱结点．．．．（简称前驱），a i+1是a i的直接后继结点．．．．（简称后继）。
4）线性表的性质：①线性表结点间的相对位置是固定．．的，结点间的关系由结点在表中的位置确定。
②如果两个线性表有相同的数据结点，但它们的结点顺序不一致，该两个线性表也是不相等的。
注意：线性表中结点的类型可以是任何数据（包括简单类型和复杂类型），即结点可以有多个成分，其中能唯一标识表元的成分称为关键字（key），或简称键。
以后的讨论都只考虑键，而忽略其它成分，这样有利于把握主要问题，便于理解。
『经典例题解析』线性表的特点是每个元素都有一个前驱和一个后继。
( )【答案】错误。
【解析】线性表的第一个数据元素没有前驱，最后一个元素没有后继。
其余的所有元素都有一个前驱和后继。
2．线性表的抽象数据类型线性表是一个相当灵活的数据结构，其长度可以根据需要增加或减少。
从操作上讲，用户不仅可以对线性表的数据元素进行访问操作，还可以进行插入、删除、定位等操作。
1）线性表的基本操作假设线性表L有数据对象 D＝{ai | ai∈ElemSet，i=1,2,3,…,n，n>=0},数据元素之间的关系R＝{<ai-1,ai>|ai-1,ai∈D,i=1,2,…,n},则线性表L的基本操作如下所示：●InitList(&L)：其作用是构造一个长度为0的线性表（空线性表）；●DestoryList(&L)：其作用是销毁当前的线性表L；●ClearList(&L)：清空线性表L，使之成为空表；●ListLength(L)：返回线性表L的长度，即线性表中数据元素的个数；●ListEmpty(L) ：判断线性表L是否为空表，是则返回True，否则返回False；●GetElem(L,i,&e)：将线性表L中第i个数据元素的值返回到变量e中；●LocateELem(L,e,compare( )) ：判断线性表L中是否存在与e满足compare（）条件的数据元素，有则返回第一个数据元素；●PriorElem(L,cur_e,&pri_e)：返回线性表L中数据元素cur_e的前驱结点；●NextElem(L,cur_e,&next_e)：返回线性表L中数据元素cur_e的后继结点；●ListInsert(&L,i,e)：向线性表L的第i个位置之前插入一个数据元素，其值为e；●ListDelete(&L,i,&e)：删除线性表L的第i个数据元素，并将该数据元素的值返回到e中；●ListTraverse(L,visit())：遍历线性表中的每个数据元素。
实验一 线性表的应用
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个数，元素间的顺序没有意义。
数据结构线性表应用
数据结构线性表应用在计算机科学领域中，数据结构是一门至关重要的学科，它为我们提供了高效组织和管理数据的方法。
其中，线性表作为一种基本的数据结构，具有广泛的应用场景。
线性表是由零个或多个数据元素组成的有限序列。
这些数据元素在逻辑上是线性排列的，也就是说，它们之间存在着一种顺序关系。
常见的线性表实现方式有顺序表和链表。
顺序表是一种采用连续存储空间来存储数据元素的线性表。
它的优点是可以随机访问元素，时间复杂度为 O(1)。
这意味着，如果我们知道元素在顺序表中的位置，就能够快速地获取到该元素。
想象一下，我们有一个学生成绩的顺序表，要查找第 10 个学生的成绩，直接根据索引就能迅速找到。
顺序表在需要频繁进行随机访问的场景中表现出色，比如在数据库中存储数据时。
然而，顺序表也有它的局限性。
当需要插入或删除元素时，如果插入或删除的位置不是在表尾，就需要移动大量的元素，时间复杂度为O(n)。
这在数据量较大时，可能会导致性能下降。
相比之下，链表则在插入和删除操作上具有优势。
链表中的每个节点包含数据元素和指向下一个节点的指针。
当进行插入或删除操作时，只需要修改相关节点的指针即可，时间复杂度为 O(1)。
比如，在一个购物车的链表中，添加或删除商品时，不需要移动其他商品的位置，操作效率很高。
线性表在日常生活中的应用比比皆是。
以我们常见的排队为例，排队的人群可以看作是一个线性表。
每个人按照先后顺序排列，新加入的人排在队尾，离开的人从队首离开。
这种先入先出的特性，与线性表中的队列结构相似。
在计算机程序中，线性表也有广泛的应用。
比如，在文本编辑软件中，我们输入的字符序列可以看作是一个线性表。
当我们进行插入、删除字符的操作时，就是对这个线性表进行修改。
再比如，在操作系统的进程管理中，进程可以按照它们的创建顺序或者优先级排列成一个线性表。
操作系统在调度进程时，需要根据线性表中的信息来决定哪个进程先执行，哪个进程后执行。
在软件开发中，线性表也常用于实现栈这种数据结构。
线性表现在建筑外立面设计中的应用
2020·07一、线性表现分类首先想要了解线的艺术概念，就先要从线的整体概念入手。
艺术和数学同属于人文艺术，在此，我们可以参照运用几何学中线条的表现理念。
在几何学中，连续不断的点的移动所形成的轨迹，就形成了线条。
艺术类别中的线条和只有长度没有厚度的几何线条有所不同，在艺术运用中，线条也是可以有厚度和宽度的。
(一)直线建筑造型的基本元素之中，直线是最基础的也是最普遍的线，无论是建筑面的连接、整体的棱还是单体的柱子，檐口、屋门、栏杆、窗格，处处都表现出来一种线性的特征。
直线包括刚硬冷峻的垂直线、亲和舒展的水平线、活泼动感的斜线。
希腊建筑中的柱就是直线的代表，斜线组成的尖角在哥特式建筑中应用甚多。
(二)曲线建筑外立面中也多用到曲线，用这一富含韵律的线性表现可以将建筑的美和灵气体现出来。
带有曲线的飞檐翘脚在我国的传统建筑中就应用广泛，其使建筑在威严庄重间体现祥和高贵。
线性表现中，直线表现一种刚硬的力量感，而曲线有一种柔美的韵律感。
运用中，曲线和直线两者结合，既有层次又有平和。
线条在艺术上的表现力体现为柔美与刚硬的人文性和通过统筹安排变化的规则性。
二、建筑外立面(一)合理性建筑外立面是建筑的外衣，既有美化建筑的作用，又有实用的用途。
合理的设计能够使得建筑艺术感与实用性并存。
比如说在如今的大型建筑设计之中，玻璃幕墙的过多运用就产生了光污染，适当减少并加入绿色设计可以让建筑林立的大都市有更多的生机。
(二)功能多样性在保证建筑外立面的实用性和合理性的前提之下，欣赏性也成为建筑外立面的一个重要功能。
比如：在一个商业街建筑群落里，建筑外立面充满商业元素，视觉冲击力强，信息元素传达力强；而在一个工业建筑群里，建筑外立面充满简洁利索的形式感。
在建筑的不断进展中，艺术的美慢慢融入其中，使得建筑外立面与以前的建筑形式有明显的不同，给人一种耳目一新的感觉。
在保证建筑与周围环境协调发展的同时，艺术的美感不能将建筑外立面的合理性打破，削弱运用功能效果以体现其表面的美感。
数据结构线性表ppt课件
01
02
03
04
插入操作
在链表的指定位置插入一个新 节点，需要修改相邻节点的指
针。
删除操作
删除链表的指定节点，需要修 改相邻节点的指针。
查找操作
从链表的头节点开始，顺序遍 历链表，直到找到目标元素或
遍历到链表末尾。
遍历操作
从链表的头节点开始，顺序访 问每个节点，直到遍历到链表
末尾。
04 线性表应用举例 与问题分析
多项式表示与计算问题
01
02
03
多项式表示方法
数组表示法和链表表示法 。
数组表示法
将多项式的系数按次序存 放在一个数组中，通过下 标表示对应的幂次。
链表表示法
每个节点包含系数和指数 两个数据域，以及一个指 向下一个节点的指针域。
一元多项式相加算法设计
• 算法思想：将两个多项式中的同类项系数相加，得到新的 多项式。
删除操作
删除指定位置i的元素，需要将i之后的元素都向前移动 一个位置。
03 链式存储结构及 其实现
链式存储结构原理及特点
链式存储结构原理
使用一组任意的存储单元存储线 性表的数据元素（这组存储单元 可以是连续的，也可以是不连续 的）。
链式存储结构特点
逻辑上相邻的元素在物理位置上 不一定相邻，元素之间的逻辑关 系是通过指针链接来表示的。
...，an组成的有序序列。
性质
集合中必存在唯一的一个“第一元素 ”。
集合中必存在唯一的一个“最后元素 ”。
除最后元素之外，均有唯一的后继。
除第一元素之外，均有唯一的前驱。
线性表与数组关系
数组是线性表的一种表现和实现形式。
线性表更侧重于逻辑概念，而数组则是这种逻辑概念在计算机中的一种存储方式。
“线性表及其应用”实验报告
序号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.1 数组数组是一种用于存储固定大小的相同类型元素的连续内存块。
数组具有随机访问的特点，可以通过下标快速定位元素。
然而，数组的大小在创建时就已经确定，无法动态调整大小，这是它的一个缺点。
1.2 链表链表是一种动态数据结构，它通过指针将元素链接在一起。
链表的大小可以在运行时动态增加或减少，但是访问链表中的元素需要从头开始遍历，效率较低。
常见的链表有单向链表和双向链表。
二、栈和队列栈和队列是两种特殊的线性表。
2.1 栈栈是一种后进先出（LIFO）的数据结构。
它的特点是只能从一端插入和删除元素。
插入和删除的这一端称为栈顶。
栈的应用领域非常广泛，例如表达式求值、函数调用、浏览器的前进和后退等。
2.2 队列队列是一种先进先出（FIFO）的数据结构。
它的特点是只能从一端插入元素，从另一端删除元素。
插入元素的这一端称为队尾，删除元素的这一端称为队头。
队列通常用于模拟排队等场景。
三、树和图树和图是非线性的数据结构。
3.1 树树是一种层次结构的数据结构，由节点和连接节点的边组成。
树具有一个根节点和若干子树。
树的应用非常广泛，例如文件系统、数据库、算法等。
3.2 图图是由节点和连接节点的边组成的非线性数据结构。
图可以表示各种实际问题，如社交网络、路由算法、遗传算法等。
四、常见的算法数据结构和算法是紧密相关的。
常见的算法包括排序算法、查找算法、图算法等。
4.1 排序算法排序算法是将一组无序的数据按照某个规则进行排序的算法。
线性表及其应用实验报告
数据结构实验报告实验名称：线性表及其应用班级：12级电气本2学号：2012081227姓名：赵雪磊指导教师：梁海丽日期：2013年9月9日数学与信息技术学院一、实验目的1、掌握线性表的概念，理解线性表的顺序、链式存储。
2、掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验要求1、建立顺序存储的线性表，并对之进行插入、删除操作。
2、建立链式存储的线性表，并对之进行插入、删除操作。
；三、算法描述#include <cstdlib>#include <iostream>#include "myList.h"using namespace std;template <class T> class Link {public:T data; // 用于保存结点元素的内容Link * next; // 指向后继结点的指针Link(const T info, Link* nextValue = NULL) { // 具有两个参数的Link构造函数data = info;next = nextValue;}Link(Link* nextValue = NULL) { // 具有一个参数的Link构造函数next = nextValue;}}// 【代码2.7】单链表的类型定义template <class T>class lnkList : public List<T> {protected:Link<T>* head, tail; // 单链表的头、尾指针public:lnkList(); // 构造函数~lnkList(); // 析构函数bool isEmpty(); // 判断链表是否为空void clear(); // 将链表存储的内容清除，成为空表int length(); // 返回此顺序表的当前实际长度bool append(T value); // 在表尾添加一个元素value，表的长度增1 bool insert(int p, T value); // 在位置p上插入一个元素value，表的长度增1 bool delete(int p); // 删除位置p上的元素，表的长度减 1int getPos(const T value); // 查找值为value的元素，并返回第1次出现的位置Link<T> setPos(int p); // 返回线性表指向第p个元素的指针值}template <class T>class lnkList:: lnkList() {head = tail = new Link<T>;}template <class T>class lnkList:: ~lnkList() {Link tmp;while (head != NULL) {tmp = head;head = head->next;delete tmp;}}template <class T> // 假定线性表的元素类型为TLink lnkList :: setPos(int i) {int count = 0;Link *p;if (i == -1) // i为-1则定位到"虚"头结点return head;p = head->next; // 若i为0则定位到第一个结点while (p != NULL && count < i) {p = p-> next;count++;};return p; // 指向第 i 结点，i＝0,1,…，当链表中结点数小于i时返回NULL }template <class T> // 假定线性表的元素类型为Tbool lnkList :: insert (int i, T value) {Link *p, *q;q = new Link<T>;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the inserted point is illegal"<<endl;return false;}q->next = p->next;q->data = value;p->next = q;if (q->next == NULL ) // 插入点在链尾，插入结点成为新的链尾tail = q;return true;}// delete a node from singly linked listtemplate <class T> // 假定线性表的元素类型为Tbool lnkList :: delete(int i) {Link *p, *q;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the deletion point is illegal"<<endl;return false;}q = p->next; // q是真正待删结点if (q == tail) // 待删结点为尾结点，则修改尾指针tail = p;if (q != NULL) { // 删除结点q 并修改链指针p->next = q->next;delete q;}return true;}template <class T> // 假定顺序表的元素类型为Tvoid lnkList<T> :: print() {while (head != NULL) {cout << head->data;cout << endl; // 从位置p开始每个元素左移直到curLen, tmp = head;head = head->next;}}四、程序清单#include <iostream.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #defineOVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2typedef struct shunxubiao{ ElemType *list;int size;int Maxsize; }SqList;int InitList_Sq(SqList &L) {// 构造一个空的线性表L。
第2章 线性表
数。
第2章 线性表
2.2 线性表的顺序存储结构表示
图2-2所示为线性表在存储介质中顺序分配的情况。
第2章 线性表
逻辑地址 1 2 记录内容 a1 a2 存储地址 LOC(a ) 1 LOC(a )＋k 1 内存状况 a1 a2
…
i
…
ai LOC(a )＋(i－1)× k 1
…
ai
…
n
图2-2 线性表的顺序分配
第2章 线性表
2.3 线性表元素的操作
2.3.1 线性表元素插入操作 插入一个记录，对有序线性表结构的影响可以从以下 两个方面分析。
(1) 若插入记录关键字的值比表中所有的数据元素的
关键字值都大，那么只需在表后添加一个新记录元素，同 时使表的当前长度修正为n+1即可。
(2) 若插入记录的位置出现在线性表的中间，则情况
LOC(ai)=LOC(a1)+(i-1)×k
从以上的地址计算公式可知，只要已知线性表第 一个数据元素在内存中的存储地址，又知道每一个数 据元素所占存储单元的个数，就能计算出第i个数据元 素在内存中的位置。
第2章 线性表 例如，线性表中第一个数据元素在内存中的地址 LOC(a1)为1000，每一个数据元素占用2个存储单位，
名称“数据结构”的属性就不相同，它们分别为字符
型和数值型。
第2章 线性表 2.1.2 线性表的逻辑结构表示 在任何问题中，数据元素之间可以存在多种关系。 从数据结构的观点来看，重要的是数据元素之间的逻辑 关系。所谓逻辑关系，是指数据元素之间的关联方式或 称“邻接关系”。表2-1中数据的逻辑结构如图2-1(b)所 示，其中的圆圈称为结点。一个结点代表一个数据元素 (有时也把结点和数据元素当作同义词)，结点之间的连 线代表逻辑关系，即相应数据元素之间的邻接关系。图 2-1(b)中的逻辑结构反映了表2-1中表格作为一个数据的 组织形式，这种组织形式就是数据元素(记录)“一个接 一个地排列”。
数据结构--实验报告_线性表的基本操作备用
实验目的实验内容和要求源代码顺序表的代码单链表的代码测试结果顺序表的测试结果单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1.帮助读者复习C++语言程序设计中的知识。
2.熟悉线性表的逻辑结构。
3.熟悉线性表的基本运算在两种存储结构上的实现。
4.掌握顺序表的存储结构形式及其描述和基本运算的实现。
5.熟练掌握动态链表结构及有关算法的设计二、实验内容题目一: 顺序表的基本操作[问题描述]实现顺序表的建立、求长度, 取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求]（1）依次从键盘读入数据, 建立带头结点的顺序表；（2）输出顺序表中的数据元素（3）求顺序表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
（6）根据算法, 将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二: 单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度, 取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据, 建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
（6）根据算法, 将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度: ";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度: "; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度: "; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下: "; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择: ";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误, 请重新选择"<<endl;break; } }}单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点, 并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){ //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;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;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共（"<<a<<"个）: "<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共（"<<b<<"个）: "<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下: "<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误, 请重新输入"<<endl;break;}}}四、测试结果顺序表的测试结果单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时, 我有点惊讶, 才学了不到一个月, 就要写实验报告。
线性表及其应用实验报告
{
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、总结经验
实验体会：对程序设计一直讳莫如深，刚接触数据结构，觉得好难，接触一段时间之后，觉得果然如此。编程一直是我的弱项，调试这个程序却是费了不少心力。如：
CH2-11 线性表的应用：一元多项式的表示和运算
在数学上，一个一元多项式Pn(x)可按升幂写成：P n (x) = p+ p1x + p2x2 + …+ pnx n它由n+1 个系数唯一确定可用一个线性表P 来表示多现式：P = ( p0 ，p1，p2，…，p n)每一项的指数i隐含在其系数pi 的序号里如何存储多项式1、全部系数顺序存储结构优点：多项式相加的算法定义十分简洁。
缺点：对S型的浪费空间S(x) = 1 + 3x10000 + 2x20000就要用一长度为20001的线性表来表示(表中仅有三个非0元素)2、非零系数顺序存储结构,必须同时存储相应的指数P n(x) = p1x e1+ p2x e2+ …+ p n x e mp i 是指数为e i的项的非0 系数，且满足0 e1< e2< …< e m= n线性表中的数据元素有两个数据项：系数和指数：((p1 ，e1)，(p2 ，e2)，…，(p m ，e m))在最坏情况下，n+1 (=m) 个系数都不为0，则比只存储每项系数的方案要多存储一倍的数据。
对于S(x)类的多项式，这种表示将大大节省空间。
3、非零系数单链表存储结构若只对多项式进行“求值”等不改变多项式的系数和指数的运算，则采用顺序存储结构即可；否则应采用链表表示。
实现一元多项式的相加运算，显然应采用链式存储结构pa(x) = 5 + 2x + x 6+ 8x 15211681550pa(x) = 5 + 2x + x 6+ 8x 15pb(x) = -2x + 3x 6 + 4x8-213648211681550如何实现用有序链表表示的多项式的加法运算？根据一元多项式相加的运算规则：1.对于两个一元多项式中所有指数相同的项，对应系数相加；2.若其和不为0 ，则构成和“多项式”中的一项；3.对于两个一元多项式中所有指数不同的项，则分别复制到“和多项式”中去；-213648211681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中0364816815504（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中2.11线性表的应用：一元多项式的加法484681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中2.11 线性表的应用：一元多项式的加法484681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中p->exp<q->expNp->exp==q->expY X=p->coef+q->coefX==0?Y 删除pN修改p结点系数，指针后移删除qP向后移Y插入q当前指针到pNvoid AddPolyn(linklist*pa, linklist*pb) { p=pa->link;q=pb->link;while(p!=NULL && q!=NULL)){ if (p->exp<q->exp) {取p的结点,p后移}else {if (p->exp==q->exp) {系数相加x= p->coef+q->coef;if x==0 删除p当前结点;else { 修改p当前结点的系数为x;p后移;}删除q当前结点；}else 将q当前结点插入到p中；}if(q!=NULL){将q剩余结点加到和多项式中} else { do nothing？？？}多项式加法涉及到的主要算法：1、建立多项式，考虑加上排序功能2、多项式的输出3、多项式的加法。
数据结构(Java版)线性表的实现和应用[完整版]
![数据结构(Java版)线性表的实现和应用[完整版]](https://img.taocdn.com/s3/m/52d59906b4daa58da1114a25.png)
实验报告
课程名称数据结构
实验项目线性表的实现及应用
实验仪器PC机一台
学院_____ 专业
班级/学号
姓名
实验日期
成绩
指导教师
北京信息科技大学
信息管理学院
（数据结构课程上机）实验报告
3.
1.实验名称、实验目的、实验内容、实验要求由教师确定，实验前由教师事先填好，然后作为实验报告模
版供学生使用；
2.实验准备由学生在实验或上机之前填写，教师应该在实验前检查；
3.实验过程由学生记录实验的过程，包括操作过程、遇到哪些问题以及如何解决等；
4.实验总结由学生在实验后填写，总结本次实验的收获、未解决的问题以及体会和建议等；
5.源程序、代码、具体语句等，若表格空间不足时可作为附录另外附页。
线性表结构
线性表结构线性表是计算机科学中一种常见的数据结构，它具有容易理解、实现简单及操作性能良好的特点，因而在计算机应用中得到了广泛的使用。
本文将介绍线性表结构的定义、结构特点、相关操作以及实际应用。
一、线性表的定义一个线性表（Linear Table）是一种抽象的数据结构，它由n（n>0）个相同类型的数据元素（成员）组成，其中每个数据元素有且仅有一个直接前驱和一个直接后继，表中最前面一个元素称为头元素，最后一个元素称为尾元素。
二、线性表的特点线性表是一种基本的数据结构，它具备以下几个基本特点：（1）表中元素有顺序关系，元素之间的次序由它们在表中出现的次序决定。
（2）线性表中的每个元素都有且仅有一个直接前驱和一个直接后继，表中的第一个元素没有前驱，表中的最后一个元素没有后继。
（3）线性表中的每个元素都属于相同的数据类型。
（4）线性表是限定性结构，它只能完成表中元素的顺序存取，不能完成元素的随机存取。
三、线性表的应用（1）线性表可以用来存储和操作顺序序列的数据，如求积分、求傅立叶变换等；（2）线性表可用于处理姓名、课程名称、学号等顺序性的数据；（3）线性表可以用于求解算法中的搜索、排序等问题，如快速排序，归并排序等。
四、线性表的操作线性表的操作要求在不改变原表结构的情况下对原表中数据进行插入、删除、更改、查找等操作，常用的操作有：（1）求长度：求表的长度即求表中元素的个数；（2）求特定元素：查找表中某一特定元素；（3）插入元素：向表中插入新的元素；（4）删除元素：删除表中指定位置的元素；（5）拼接表：将两个不同的表拼接成一个表；（6）按序访问：按照表元素在表中出现的次序进行操作。
五、线性表的实际应用线性表在实际应用中被广泛使用，下面简单介绍几个常见的应用场景：（1）链表是重要的动态存储结构，可以用其实现稀疏矩阵的存储；（2）在关系数据库中，用户可以使用线性表来表示关系表本身；（3）操作系统中，可以使用线性表来存储进程调度表、用户登录信息表等；（4）线性表还可以用于各种算法的求解，比如排序算法和回溯法等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构
项目2
线性表及应用
在学生成绩管理系统中建立学生信息表的过程就是初始化顺序表，如 果设置学生信息表的长度为0，则顺序表中就没记录。当然也可以根 据输入学生的记录数对L->length赋值。 建立并初始化学生信息表的程序段如下。 【程序段2-2】 定义顺序存储结构 // 见程序段2-1 main() { SeqList L; int i; printf("请输入学号，姓名，性别，成绩："); for(i=1;i<3;i++) // 结点内容初始化 scanf("%d%s%s%f",&L.elem[i].num,L.elem[i].name, L.elem[i].sex,&L.elem[i].score); L.length=--i; //顺序表长度初始化 } 程序说明，在本例中共输入两条学生的信息，对线性表的初始化，除了 对长度length赋值，还需对结点内容初始化。
如图2.2所示，已知该线性表的首地址(a1)为b，那么任意 一个元素的地址为： ai=b＋(i-1)×d(其中d为该类型元素所占空间)。
第9页 2013年7月30日星期二
数据结构
项目2
ቤተ መጻሕፍቲ ባይዱ
线性表及应用
在C语言中，一维数组的元素就是存放在一块连续的存储空间 中的，故可借助于C语言中的一维数组类型来描述线性表的顺 序存储结构。 #define MAXSIZE 1024 //线性表的最大长度 typedef struct { //表的类型 ElemType elem[MAXSIZE]; //表的存储空间 int length; //线性表长度 } SeqList; //表的说明符 例如1、3、5、7组成的线性表的结构定义如下。 typedef struct { //表的类型 int elem[5]; //表的存储空间 int length; //线性表长度 } SeqList; //表的说明符 在C语言中，定义一个顺序表的语句是： SeqList *L ；
第6页
2013年7月30日星期二
数据结构
项目2
线性表及应用
(5) 插入操作：Insert_List(L,i,x)。 初始条件：线性表L存在，插入位置正确(1≤i≤n+1，n为插入前的表长)。 操作结果：在线性表L的第i个位置上插入一个值为x的新元素，这样使原 序号为i, i+1,…, n 的数据元素的序号变为i+1,i+2,…, n+1，插 入后，表长=原表长+1。 (6) 删除操作：Delete_List(L,i) 初始条件：线性表L存在，1≤i≤n。 操作结果：在线性表L中删除序号为i的数据元素，删除后使序号为i+1, i+2,…, n的元素变为序号为i, i+1,…,n-1，新表长=原表长-1。 需要说明以下两点。 (1) 数据结构上的基本运算，不是它的全部运算，而是一些常用的基本 运算，而每一个基本运算在实现时也可能根据不同的存储结构派生 出一系列相关的运算来。 (2) 在上面各操作中定义的线性表Ｌ仅仅是一个抽象在逻辑结构层次的 线性表，尚未涉及到它的存储结构，因此每个操作在逻辑结构层次 上尚不能用具体的某种程序语言写出具体的算法，而算法的实现只 有在存储结构确立之后才能确定。
学号
2009001 2009002 2009003 … 2009010
姓名
张三 李玉 王平 … 刘芳
性别
男 女 男 … 女
成绩
53 67 78 … 45
第3页
2013年7月30日星期二
数据结构
项目2
线性表及应用
子任务2.1.1 理解线性表的定义 1.定义：线性表是具有相同数据类型的n(n≥0)个数据元素的 有限序列，上面例子中的每个元素就是一个结点，通常记为： (a1，a2，…，ai-1，ai，ai+1，…，an) 其中n为表长，n=0时称为空表。 关键点: (1) 相同数据类型 (2) 线性表的长度 n (n≥0) (3) 有限序列
实现。掌握线性表的两种存储结构的运算特点，能够解决
现实生活中线性结构的实际问题。
第2页
2013年7月30日星期二
数据结构
任务2.1
项目2
线性表及应用
理解线性表的逻辑结构
下面我们来看几个例子。 例1：字母序列{A,B,C,D,E,F}。 例2：奇数序列{1,3,5,7,9,11}。 例3：学生成绩表表2-1。
第7页
2013年7月30日星期二
数据结构
项目2
线性表及应用
ADT List { 数据对象：D={ai|ai∈ ElemType i=1,2, ···,n , n ≥0 } 数据关系：R={ <ai, ai+1> | ai , ai+1 ∈ D i=1,2, ···,n-1, n ≥0 } 基本操作如下。 InitList(&L)：线性表的初始化。 ListLength(L)：求线性表的长度。 ListInsert(&L , i , e)： 在第i个位置插入元素e。 ListDelete(&L , i , e)：在线性表第i个位置删除元素e。 Location(L, e)：定e的位置。
第11页
2013年7月30日星期二
数据结构
项目2
线性表及应用
子任务2.2.2 顺序表上基本运算的实现 ——用顺序表完成学生成绩管理系统
首先学生成绩管理系统的功能分解图如图2.3所示。
学生成绩管理系统
初 始 化 学 生 信 息
插 入 学 生 记 录
删 除 学 生 记 录 除
查 询 学 生 信 息 信
第8页
2013年7月30日星期二
数据结构 任务2.2
项目2
线性表及应用
线性表的顺序表示和实现
子任务2.2.1 建立顺序表 顺序表是指在内存中用一块地址连续的存储空间，按顺序 存储线性表的各个数据元素。线性表顺序存储示意图如图 2.2所示。
数组下标 Data a1 存储地址 b a2 b+d ·· · ·· · ai-1 ·· · ai b+(i-1)d ai+1 ·· · ·· · ·· · an ·· · ·· · b+( length -1)d 1 2 i-1 i ·· · n-1 length ·· · MAXSIZE-1
第10页 2013年7月30日星期二
数据结构
项目2
线性表及应用
那么，顺序表的长度为L->length; 数据元素范围是L->data[1]～L->data[L->length]。 因为在 C语言中数组的下标是从0开始的，为了与线性表中数据元素的序号保持 一致，不使用数组下标为0的单元，下标的取值范围为1≤i≤MAXSIZE-1。 用100个学生信息建立学生成绩管理系统顺序表的程序段如下。 【程序段2-1】 #define MAXSIZE 100 typedef struct //定义结点类型 { long int num; char name[10]; char sex[3]; float score; }ElemType; typedef struct { //定义顺序存储结构 ElemType elem[MAXSIZE]; int length; /* 线性表长度 */ } SeqList; SeqList *L ; //定义学生信息的顺序表
3.举例： A=(１,３,５,７,９) B=(a1 ,a2 ,a3 ,·，am) · · C=(b1 ,b2 ,b3 ,·，bn) · ·
该线性表的长度为 5 该线性表的长度为 m 该线性表的长度为 n
第4页
2013年7月30日星期二
数据结构
项目2
线性表及应用
一个线性表可以用一个标识符来命名，例如用L命名上面的线性表，则： L=(a1，a2，…，ai-1，ai，ai+1，…，an) 线性表的逻辑图如图2.1所示。
第5页 2013年7月30日星期二
数据结构 子任务2.1.2
项目2
线性表及应用
理解线性表的基本操作
线性表上的基本操作有以下几种。 (1) 初始化线性表：Init_List(L)。 初始条件：表L不存在。 操作结果：构造一个空的线性表。 (2) 求线性表的长度：Length_List(L)。 初始条件：表L存在。 操作结果：返回线性表中所含元素的个数。 (3) 取表元：Get_List(L,i)。 初始条件：表L存在且1≤i≤Length_List(L)。 操作结果：返回线性表L中的第ｉ个元素的值或地址。 (4) 按值查找：Locate_List(L,x)，x是给定的一个数据元素。 初始条件：线性表L存在。 操作结果：在表L中查找值为x的数据元素，返回在L中首次出现的值为x的 那个元素的序号或地址，称为查找成功；否则，在L中未找到值为x的数据 元素，返回一个特殊值表示查找失败。
浏 览 学 生 信 息 信
退 出 本 系 统 理
生
学
息
息
第12页
2013年7月30日星期二
数据结构
项目2
线性表及应用
【模块1】初始化学生信息 该模块是对顺序表的初始化，例如构造一个空表，语法如下。 【算法2.1】 SeqList init_SeqList(SeqList *L) { L->length =0; } 算法说明：在定义顺序表之后，只要设置顺序表的长度为0 就构造了一个空的线性表。 设调用函数为主函数，主函数对初始化函数的调用如下。 main() { Seqlist *L; L=Init_Seqlist(); }
数据结构
项目2
线性表及应用
线性表的逻辑结构 线性表的顺序表示和实现 线性表的链式表示和实现