数据结构---三元组顺序表------稀疏矩阵的转置和快速转置
数据结构---三元组顺序表------稀疏矩阵的转置和快速转置
#include
#include
#include
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INEEASLIBE -1
#define OVERFLOW -2
#define maxsize 100
typedef int status;
typedef int elemtype;
typedef struct
{
int i,j;
elemtype e;
}elem;
typedef struct
{
elem data[maxsize+1];
int mu,mn,tu;
}matrix;
status showmatrix(matrix M)
{
int i,j,k=1;
for(i=1;i<=M.mu;i++)
{
for(j=1;j<=M.mn;j++)
{
if(i==M.data[k].i&&j==M.data[k].j)
{
printf("%d\t",M.data[k].e);
k++;
}
else
printf("0\t");
}
printf("\n");
}
return OK;
}
status trans(matrix M,matrix &T)
{
int i=1,j=1,k=1;
T.tu=M.tu;
T.mn=M.mu;
T.mu=M.mn;
while(i<=M.mn)
{
for(;k<=M.tu;k++)
if(M.data[k].j==i)
{
T.data[j].e=M.data[k].e;
T.data[j].i=M.data[k].j;
T.data[j].j=M.data[k].i;
j++;
}
k=1;
i++;
}
return OK;
}
status initmatrix(matrix &M)
{
printf("请输入该矩阵行数mu和列数mn和非零元个数tu\nmu=");
scanf("%d",&M.mu);
getchar();
printf("\nmn=");
scanf("%d",&M.mn);
getchar();
printf("\ntu=");
scanf("%d",&M.tu);
getchar();
if(M.tu>maxsize)
{
printf("非零元个数已超过定义的值\n请重新输入tu=");
scanf("%d",&M.tu);
getchar();
}
printf("请输入非零元和它所在的行数和列数(矩阵从先从左到右，再从上到下输入)\n");
for(int i=1;i<=M.tu;i++)
{
if(i==1)
printf("输入非零元:");
else
printf("输入下一个非零元:");
scanf("%d",&M.data[i].e);
getchar();
printf("输入该非零元的行数:");
scanf("%d",&M.data[i].i);
getchar();
while(M.data[i].i>M.mu||M.data[i].i<1)
{
printf("输入的行数不合法\n请重新输入行数:");
scanf("%d",&M.data[i].i);
getchar();
}
printf("输入该非零元的列数:");
scanf("%d",&M.data[i].j);
getchar();
while(M.data[i].j>M.mn||M.data[i].j<1)
{
printf("输入的列数不合法\n请重新输入列数:");
scanf("%d",&M.data[i].j);
getchar();
}
}
return OK;
}
status fasttrans(matrix M,matrix &T)
{
T.tu=M.tu;
T.mn=M.mu;
T.mu=M.mn;
int *num,*pose;
num=(int*)malloc(M.mn*sizeof(int));
pose=(int*)malloc(M.mn*sizeof(int));
*(pose)=1;
int i=1;
for(;i<=M.mn;i++)
*(num+i-1)=0;
for(i=1;i<=M.tu;i++)
{
*(num+M.data[i].j-1)=*(num+M.data[i].j-1)+1;
}
for(i=2;i<=M.mn;i++)
{
*(pose+i-1)=*(pose+i-2)+*(num+i-2);
}
for(i=1;i<=M.tu;i++)
{
T.data[*(pose+M.data[i].j-1)].i=M.data[i].j;
T.data[*(pose+M.data[i].j-1)].j=M.data[i].i;
T.data[*(pose+M.data[i].j-1)].e=M.data[i].e;
*(pose+M.data[i].j-1)=*(pose+M.data[i].j-1)+1;
}
return OK;
}
main()
{
matrix M,T;
char c;
while(1)
{
printf("1:初始化矩阵\n2:显示矩阵\n3:普通转置\n4:快速转置\n");
scanf("%c",&c);
getchar();
switch(c)
{
case '1':
if(initmatrix(M)==OK)
printf("初始化成功\n");
break;
case '2':
showmatrix(M);
break;
case '3':
trans(M,T);
printf("转置后矩阵为:\n");
showmatrix(T);
break;
case '4':
fasttrans(M,T);
printf("转置后矩阵为:\n");
showmatrix(T);
break;
default:
printf("输入不合法\n");
break;
}
}
}
三元组表示稀疏矩阵的转置(一般算法和快速算法)
一、设计要求 1．1 问题描述 稀疏矩阵是指那些多数元素为零的矩阵。利用稀疏特点进行存储和计算可以大大节省存储空间，提高计算效率。求一个稀疏矩阵A的转置矩阵B。 1．2需求分析 （1）以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现稀疏矩阵的转置运算。（2）稀疏矩阵的输入形式采用三元组表示，运算结果则以通常的阵列形式列出。 （3）首先提示用户输入矩阵的行数、列数、非零元个数，再采用三元组表示方法输入矩阵，然后进行转置运算，该系统可以采用两种方法，一种为一般算法，另一种为快速转置算法。（4）程序需要给出菜单项，用户按照菜单提示进行相应的操作。 二、概要设计 2．1存储结构设计 采用“带行逻辑链接信息”的三元组顺序表表示矩阵的存储结构。三元组定义为：typedef struct { int i；//非零元的行下标 int j；//非零元的列下标 ElemType e; //非零元素值 }Triple; 矩阵定义为： Typedef struct { Triple data[MAXSIZE+1]; //非零元三元组表 int rpos[MAXRC+1]; //各行第一个非零元的位置表 int mu,nu,tu; //矩阵的行数、列数和非零元个数 }RLSMatrix; 例如有矩阵A，它与其三元组表的对应关系如图
2．2 系统功能设计 本系统通过菜单提示用户首先选择稀疏矩阵转置方法，然后提示用户采用三元组表示法输入数据创建一个稀疏矩阵，再进行矩阵的转置操作，并以通常的阵列形式输出结果。主要实现以下功能。 （1）创建稀疏矩阵。采用带行逻辑连接信息的三元组表表示法，提示用户输入矩阵的行数、列数、非零元个数以及各非零元所在的行、列、值。 （2）矩阵转置。<1>采用一般算法进行矩阵的转置操作，再以阵列形式输出转置矩阵B。 <2>采用快速转置的方法完成此操作，并以阵列形式输出转置矩阵B。 三、模块设计 3．1 模块设计 程序包括两个模块：主程序模块、矩阵运算模块。 3．2 系统子程序及其功能设计 系统共设置了8个子程序，各子程序的函数名及功能说明如下。 （1）CreateSMatrix(RLSMatrix &M) //创建稀疏矩阵 （2）void DestroySMatrix(RLSMatrix &M) //销毁稀疏矩阵 （3）void PrinRLSMatrix(RLSMatrix M) //遍历稀疏矩阵 （4）void print(RLSMatrix A) //打印矩阵函数，输出以阵列形式表示的矩阵 （5）TransposeSMatrix(RLSMatrix M,RLSMatrix &T) //求稀疏矩阵的转置的一般算法（6）FastTransposeSMatrix(RLSMatrix M,RLSMatrix &T) //快速转置算法 （7）void showtip() //工作区函数，显示程序菜单 （8）void main() //主函数
数据结构实验报告——顺序表链表的实现
课程名称：数据结构任课教师： 实验题目：线性表的基本操作 实验环境： Visual C++ 6.0 实验目的： 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的的顺表序和链表，使其具有如下功能： (1)根据指定学生个数，逐个输入学生信息; (2)逐个显示学生表中所有学生的相关信息；
(3)根据姓名进行查找，返回此学生的学号和成绩；
(4)根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5)给定一个学生信息，插入到表中指定的位置； int createStLink(struct Node *head,struct Node *stu) { struct Node *p6,*p7,*p8; p7=head; p6=stu; if(head==NULL) { head=p6;p6->next=NULL; } else { //如果链表为空则在头结点创建信息while(p6->num > p7->num && p7->next!=NULL)
{ p8=p7; p7=p7->next; } if(p6->num<=p7->num) { if(head==p7) head=p6; else p8->next=p6; p6->next=p7; } else { p7->next=p6;p6->next=NULL; } } N++; return 1; } int main() { struct Node *H,*stud; char M; int num1; H=initlist(); (6)删除指定位置的学生记录;
线性表练习题(答案)
第2章线性表 一选择题 下列程序段的时间复杂度为（ C ）。 for( int i=1;i<=n;i++) for( int j=1;j<= m; j++) A[i][j] = i*j ; A. O(m2) B. O(n2) C. O(m*n) D. (m+n) 下面关于线性表的叙述中，错误的是哪一个？（B ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 线性表是具有n个（ C ）的有限序列（n>0）。 A．表元素B．字符C．数据元素D．数据项 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（ A ）存储方式最节省时间。 A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（ D ）存储方式最节省运算时间。 A．单链表B．仅有头指针的单循环链表 C．双链表D．仅有尾指针的单循环链表 设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( D )最节省时间。A. 单链表 B.单循环链表 C. 带尾指针的单循环链表 D.带头结点的双循环链表 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用（ D ）存储方式最节省运算时间。 A．单链表B．双链表C．单循环链表D．带头结点的双循环链表 链表不具有的特点是（ B ） A．插入、删除不需要移动元素B．可随机访问任一元素 C．不必事先估计存储空间D．所需空间与线性长度成正比 下面的叙述不正确的是（B,C ） A．线性表在链式存储时，查找第i个元素的时间同i的值成正比 B. 线性表在链式存储时，查找第i个元素的时间同i的值无关 C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比 D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关 若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（ C ）(1<=i<=n+1)。 A. O(0) B. O(1) C. O(n) D. O(n2) 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（C ）。 A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1) 线性表（a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂性为（ C ）A．O（i）B．O（1）C．O（n）D．O（i-1） 循环链表H的尾结点P的特点是（A ）。 A．P->next=H B．P->next= H->next C．P=H D．P=H->next 完成在双循环链表结点p之后插入s的操作是（D ）；
线性表顺序存储结构上的基本运算
实验项目名称：线性表的顺序存储结构上的基本运算 （所属课程：数据结构--用C语言描述） 院系：计算机科学与信息工程学院专业班级：网络工程 姓名：000000 学号：0000000000 实验日期：2016.10.20 实验地点：A-06 406 合作者：指导教师：孙高飞 本实验项目成绩：教师签字：日期： （以下为实验报告正文） 一、实验目的 本次实验的目的掌握顺序表的存储结构形式及其描述和基本运算的实现；掌握动 态链表结构及相关算法设计 实验要求：输入和验证程序例题。正确调试程序，记录程序运行结果。完成实验报 告。 二、实验条件 Windows7系统的电脑，vc++6.0软件，书本《数据结构--用c语言描述》 三、实验内容 3.1 根据41页代码，用c语言定义线性表的顺序存储结构。 3.2 根据42页算法2.1实现顺序表的按内容查找。 3.3 根据43页算法2.2实现顺序表的插入运算。 3.4 根据45页算法2.3实现顺序表的删除运算。 四、实验步骤 3.2实验步骤 （1）编写头文件，创建ElemType。 （2）根据根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。
（3）根据42页算法2.1实现顺序表的按内容查找，创建Locate函数。 （4）创建main函数，输入SeqList L的数据元素。 （5）输入要查找的数据元素的值，调用Locate函数，输出结果。 3.3实验步骤 （1）编写头文件，创建ElemType。 （2）根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。 （3）根据43页算法2.2实现顺序表的插入运算，创建InsList函数。 （4）创建printList函数，逐项输出顺序表内的元素及顺序表元素的个数。 （5）创建main函数，输入插入的元素和其位置，调用printLinst函数输出顺序表，调用IntList函数，再次调用printLinst函数输出顺序表。 3.4实验步骤 （1）编写头文件，创建ElemType。 （2）根据根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。 （3）根据45页算法2.3实现顺序表的删除运算，创建DelList函数。 （4）创建printList函数，逐项输出顺序表内的元素及顺序表元素的个数。 （5）创建main函数，输入删除元素的位置，调用printLinst函数输出顺序表，调用DelList函数，再次调用printLinst函数输出顺序表。 五、实验结果 （1）实验3.2顺序表的按内容查找 # include
数据结构顺序表真题
第二章复习题 本章重点掌握：线性结构特点，顺序存储结构和链式存储结构特点。 1.在顺序表中插入或删除一个元素，需要平均移动( 一半 )元素，具体移动的元素个数与( 插入或删除的位置 )有关。插入时平均 次数（n/2 ）,删除时平均次数（(n-1)/2 ）。 2.有一个含头结点的循环链表，头指针为 head, 则其为空的条件是：( C ) A)head==NULL B)head->next==NULL C)head->next==head 3.在长度为 n 的顺序表的第 i 个位置上插入一个元素（1≤i≤n+1），元素的移动次数为：( A ) A) n – i + 1 B) n – i C) i D) i – 1 4.对于只在表的首、尾两端进行插入操作的线性表，宜采用的存储结构为( C ) A)顺序表B) 用头指针表示的循环单链表 C) 用尾指针表示的循环单链表D) 单链表 5.设单链表中结点的结构为（data, link）。已知指针 q 所指结点是指针 p 所指结点的直接前驱，若在*q 与*p 之间插入结点*s，则应执行下列哪一个操作？（ B ） A)s->link = p->link;p->link = s;(B) q->link = s;s->link = p; (C) p->link = s->link;s->link = p;(D) p->link = s;s->link = q; 6.设单链表中结点的结构为（data, link）。已知指针 p 所指结点不是尾结点，若在*p 之后插入结点*s，则应执行下列哪一个操作？（B）
A)s->link = p;p->link = s;(B) s->link = p->link;p->link = s; (C) s->link = p->link;p = s;(D) p->link = s;s->link = p; 7.设单链表中结点的结构为（data, link）。若想摘除结点*p 的直接后继，则应执行下列哪一个操作？（A） (A) p->link = p->link->link; (B) p = p->link;p->link = p->link->link; (C) p->link = p->link;(D) p = p->link->link; 8.设单循环链表中结点的结构为（data, link），且 rear 是指向非空的 带表头结点的单循环链表的尾结点的指针。若想删除链表第一个结点，则应执行下列哪一个操作？（D） (A)s = rear;rear = rear->link;delete s; (B)rear = rear->link;delete rear; (C)rear = rear->link->link;delete rear; (D)s = rear->link->link;rear->link->link = s->link; delete s; （rear 指向尾结点，rear->link->link 指向第一个结点，第一个结点变为原来的第二个结点） 9.设双向循环链表中结点的结构为（data, lLink, rLink），且不带表头 结点。若想在指针 p 所指结点之后插入指针 s 所指结点，则应执 行下列哪一个操作？( D )
数据结构稀疏矩阵转置,加法
《数据结构》实验报告 ◎实验题目:稀疏矩阵的转置、加法（行逻辑链接表） ◎实验目的：学习使用三元组顺序表表示稀疏矩阵，并进行简单的运算 ◎实验内容：以三元组表表示稀疏矩阵，并进行稀疏矩阵的转置和加法运算。 一、需求分析 该程序目的是为了用三元组表实现稀疏矩阵的转置和加法运算。 1、输入时都是以三元组表的形式输入； 2、输出时包含两种输出形式：运算后得到的三元组表和运算后得到的矩阵； 3、测试数据： （1）转置运算时输入三元组表：1 2 12 1 3 9 3 1 -3 3 6 14 4 3 24 5 2 18 6 1 15 6 4 -7 得到转置后的三元组表：1 3 -3 1 6 15 2 1 12 2 5 18 3 1 9 3 4 24 4 6 -7 6 3 14 （2）进行加法运算时先输入矩阵A（以三元组表形式）：1 1 1 2 2 2 2 3 4 3 1 -4 输入矩阵B（以三元组表形式）：1 3 -2 2 3 -5 3 1 8 3 2 -6 A与B的和矩阵以矩阵形式输出为：1 0 -2 0 2 -1 4 -6 0 (二) 概要设计 为了实现上述操作首先要定义三元组表，稀疏矩阵： typedef struct { int i,j; int e; }Triple;//三元组
typedef struct { Triple data[MAXSIZE+1]; int mu,nu,tu; }Matrix;//稀疏矩阵 1.基本操作 void CreatMatrix(Matrix *m) 操作结果：创建一个稀疏矩阵。 void PrintMatrix(Matrix m) 初始条件：矩阵m已存在。 操作结果：将矩阵m以矩阵的形式输出。 void FastTransposeMatrix(Matrix a,Matrix *b) 初始条件：稀疏矩阵a已存在； 操作结果：将矩阵a进行快速转置后存入b中。 void AddMatrix(Matrix a,Matrix b,Matrix *c) 初始条件：稀疏矩阵a和b都已存在； 操作结果：将矩阵a和b的和矩阵存入c中。 2.本程序包含了两个模块： （1）头文件模块； 其中包括定义三元组表Triple和稀疏矩阵Matrix，以及创建矩阵void CreatMatrix(Matrix *m)和输出矩阵void PrintMatrix(Matrix m)两个函数； （2）主程序模块； 包括主函数main()，快速转置函数void FastTransposeMatrix(Matrix a,Matrix *b)和实现矩阵相加函数void AddMatrix(Matrix a,Matrix b,Matrix *c) (三) 详细设计 定义三元组和稀疏矩阵类型： typedef struct { int i,j; int e; }Triple; typedef struct { Triple data[MAXSIZE+1]; int mu,nu,tu; }Matrix; 创建头文件:“Matrix.h” void CreatMatrix(Matrix *m)//矩阵的初始化 { int p=1,a,b,c; printf("请输入矩阵的行数、列数、非零元的个数（数据用空格隔开）:"); scanf("%d %d %d",&(*m).mu,&(*m).nu,&(*m).tu);
数据结构- 顺序表的基本操作的实现-课程设计-实验报告
顺序表的基本操作的实现 一、实验目的 1、掌握使用VC++上机调试顺序表的基本方法； 2、掌握顺序表的基本操作：建立、插入、删除等运算。 二、实验仪器 安装VC++软件的计算机。 三、实验原理 利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容 程序中演示了顺序表的创建、插入和删除。 程序如下： #include
i nt i,x; i nt n=10; L.length=0; c lrscr(); C reateList(&L,n); /*建立顺序表*/ P rintList(&L,n); /*打印建立后的顺序表*/ p rintf("INPUT THE RESEARCH ELEMENT"); s canf("%d",&x); i=LocateList(&L,x); p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n"); s canf("%d",&i); p rintf("input the value of insert\n"); s canf("%d",&x); I nsertList(&L,x,i); /*顺序表插入*/ P rintList(&L,n); /*打印插入后的顺序表*/ p rintf("input the position of delete\n"); s canf("%d",&i); D eleteList(&L,i); /*顺序表删除*/ P rintList(&L,n); /*打印删除后的顺序表*/ g etchar(); } /*顺序表的建立：*/ void CreateList(SeqList *L,int n) {int i; printf("please input n numbers\n"); for(i=1;i<=n;i++) scanf("%d",&L->data[i]); L->length=n;
线性表的顺序存储结构定义和基本操作算法实现
/************线性表的顺序存储结构定义和基本操作算法实现************/ #include "stdio.h" /***********************线性表的顺序存储结构定义*******************/ #define MAX 11 /*线性表可能达到的最大长度值*/ typedef int datatype; typedef struct {datatype data[MAX]; int last;}list; /************************1.线性表的初始化***************************/ void init(list *lp) {lp->last=0;} /************************2.求线性表的长度***************************/ int length(list *lp) { return (lp->last);} /***************3.插入运算,在表第i个位置插入一个值为x的新元素******/ void insert(list *lp,int i,datatype x) { int j; if(lp->last==MAX-1) printf("Overflow!\n"); /*表已满*/ else if(i<1||i>lp->last+1) printf("Error!\n"); /*插入位置错误*/ else {for(j=lp->last;j>=i;j--) lp->data[j+1]=lp->data[j]; /*数据元素后移*/ lp->data[i]=x; /*插入x */ lp->last++; /*表长度加1*/ } } /***************4.删除运算,在表中删除第i个数据元素***************/ void delete(list *lp,int i) { int j; if(i<1||i>lp->last) /*检查空表及删除位置的合法性*/ printf("The %dth element is not exist!",i); /*不存在第i个元素*/ else {for(j=i+1;j<=lp->last;j++) lp->data[j-1]=lp->data[j]; /*向前移动元素*/ lp->last--; /*表长度减1 */ } } /*****************5.查找运算,在表中查找x数据元素*****************/ int locate(list *lp,datatype x) { int i=lp->last; while(i>0 && lp->data[i]!=x)i--; return i;
数据结构顺序表的查找插入与删除
一、上机实验的问题和要求： 顺序表的查找、插入与删除。设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。具体实现要求： 1.从键盘输入10个整数，产生顺序表，并输入结点值。 2.从键盘输入1个整数，在顺序表中查找该结点的位置。若找到，输出结点的位置；若找 不到，则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插 入在对应位置上，输出顺序表所有结点值，观察输出结果。 4.从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。 二、源程序及注释： #include
稀疏矩阵的建立与转置
实验2 稀疏矩阵的建立与转置 一、实验目的 掌握特殊矩阵的存储和操作算法。 二、实验内容及问题描述 实现用三元组保存稀疏矩阵并实现矩阵转置的算法。 三、实验步骤 1. 定义稀疏矩阵的三元组形式的存储结构。 2. 实现三元组矩阵的传统转置算法。 3. 实现三元组矩阵的快速转置算法。 4. 输入矩阵非零元素，测试自己完成的算法。 四、程序流程图
五、概要设计 矩阵是很多的科学与工程计算中研究的数学对象。在此，我们感兴趣的是，从数学结构这门学科着眼，如何存储矩阵的元从而使矩阵的各种运算有效的进行。本来，用二维数组存储矩阵，在逻辑上意义是很明确的，也很容易理解，操作也很容易和方便。但是在数值分析中经常出现一些阶数很高的矩阵，同时，在矩阵中又有很多值相同或者都为零的元素，可以对这种矩阵进行压缩存储：对多个值相同的元素只分配一个存储空间；对零元素不分配空间。稀疏矩阵的定义是一个模糊的定义：即非零元个数较零元个数较少的矩阵。例如下图所示的矩阵 为一个稀疏矩阵。为了实现稀疏矩阵的这种存储结构，引入三元组这种数据结构。三元组的线性表顺存储形式如下图： 六、详细设计 sanyuanzu.h 头文件 #define max 100 typedef struct { int row,col; int e; }Triple;//定义三元组 typedef struct { Triple data[max]; int mu,nu,tu; }TSMatrix;///*定义三元组的稀疏矩阵*/ void creat( TSMatrix &M) ; void fasttrans(TSMatrix A,TSMatrix &B);
数据结构顺序表的实现
实验3 顺序表 一、实验目的 1. 熟练掌握顺序表的类型定义和基本操作算法（以建立、插入、删除、遍历、排序和归并等操作为重点）的实现。 2. 通过实验加深对C语言的使用（特别是函数、数组、结构体和指针）。 3. 掌握模块化程序设计方法。 二、预备知识 1. 顺序表的类型定义 //线性表存储空间的初始分配量 #define LIST_Init_Size 100 //线性表存储空间的分配增量 #define LISTINCREMENT 10 typedef struct{ ElemType *elem; //存储区域基地址 int length; //当前有效长度 int listsize；//当前分配的存储容量 } SqList, *PSqList; 2. 顺序表的基本操作 1）初始化线性表InitList(&L) 该运算的结果是构造一个空的线性表L，为线性表分配存储空间用于存放数据元素。 2）销毁线性表DestroyList(&L ) 该运算的结果是释放线性表L占用的内存空间。 3）判定是否为空表ListEmpty(L)
该运算返回一个值表示L是否为空表。若L为空表,则返回1,否则返回0。4）求线性表的长度ListLength(L) 该运算返回顺序表L的长度。实际上只需返回length成员的值即可。 5）PriorElem( L, cur_e, &pre_e ) 该运算返回给定数据元素的前驱数据元素的值 6）NextElem( L, cur_e, &next_e ) 该运算返回给定数据元素的后继数据元素的值 7）输出线性表DispList(L) 该运算当线性表L不为空时,顺序输出L中各数据元素的值。 8）求某个数据元素值GetElem(L,i,&e) 该运算返回L中第i(1≤i≤ListLength(L))个元素的值,存放在e中。 8）按元素值查找LocateElem(L,e) 该运算顺序查找第1个值域与e相等的数据元素的序号。若这样的元素不存在,则返回值为0。 9）插入数据元素ListInsert(&L,i,e) 该运算在顺序表L的第i个位置(1≤i≤ListLength(L)+1)上插入新的元素e。10）删除数据元素ListDelete(&L,i,&e) 该运算删除顺序表L的第i(1≤i≤ListLength(L))个元素。 11）清空线性表ClearList( &L ) 删除线性表L中的所有数据元素，但不释放已分配给线性表的存储空间。2. 两个有序表的归并算法 void MergeList(SqList La, SqList Lb, PSqList PLc) { InitList(PLc); // 构造空的线性表Lc i = j = 1; k = 1; La_len = ListLength(La); Lb_len = ListLength(Lb);
线性表的顺序储存结构
交通大学《算法与数据结构》课程 实验报告 班级：计算机科学与技术2014级2班 实验项目名称：线性表的顺序储存结构 实验项目性质： 实验所属课程：算法与数据结构 实验室(中心)： B01407 指导教师：鲁云平 实验完成时间：2016 年 3 月21 日
一、实验目的 1、实现线性表的顺序存储结构 2、熟悉C++程序的基本结构，掌握程序中的头文件、实现文件和主文件之 间的相互关系及各自的作用 3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现 二、实验容及要求 对顺序存储的线性表进行一些基本操作。主要包括： （1）插入：操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入 （2）删除：操作方式可分为删除指定元素、删除指定位置的元素等，尝试实现逻辑删除操作。 （3）显示数据 （4）查找：查询指定的元素（可根据某个数据成员完成查询操作） （5）定位操作：定位指定元素的序号 （6）更新：修改指定元素的数据 （7）数据文件的读写操作等。 其它操作可根据具体需要自行补充。 要求线性表采用类的定义,数据对象的类型自行定义。 三、实验设备及软件 VC6.0 四、设计方案
㈠题目 线性表的顺序存储结构 ㈡设计的主要思路 1、新建SeqList.h头文件，定义SeqList模板类 2、设计类数据成员，包括：T *data（用于存放数组）、int maxSize （最大可容表项的项数）、int last（当前已存表项的最后位置） 3、设计类成员函数，主要包括： int search(T& x)const;//搜索x在表中位置，函数返回表项序号 int Locate(int i)const;//定位第i个表项，函数返回表项序号 bool getData(int i,T& x)const;//去第i个表项的值 void setData(int i,T& x)//用x修改第i个表项的值 bool Insert(int i,T& x);//插入x在第i个表项之后 bool Remove(int i,T& x); //删除第i个表项，通过x返回表项的值 bool IsEmpty();//判表空否，空则返回true；否则返回false bool IsFull();//判表满否，满则返回true；否则返回false void input(); //输入 void output();//输出 void ofile();/存储在文件中 void ifile();//读取文件并显示 ㈢主要功能 1、建立新表 2、对表进行插入（指定元素前、后以及指定位置插入）、删除（指定 元素删除及指定位置删除）、修改等操作 3、显示当前操作表的全部容 4、存储在文件中 5、从文件中读取表 五、主要代码 ㈠SeqList.h中的主要代码： 1、类成员声明部分： protected: T *data; //存放数组 int maxSize; //最大可容纳表项
数据结构实现顺序表的各种基本运算(20210215233821)
实现顺序表的各种基本运算 一、实验目的 了解顺序表的结构特点及有关概念，掌握顺序表的各种基本操作算法思想及其实现。 二、实验内容 编写一个程序，实现顺序表的各种基本运算： 1、初始化顺序表； 2 、顺序表的插入； 3、顺序表的输出； 4 、求顺序表的长度 5 、判断顺序表是否为空； 6 、输出顺序表的第i位置的个元素； 7 、在顺序表中查找一个给定元素在表中的位置； 8、顺序表的删除； 9 、释放顺序表 三、算法思想与算法描述简图
主函数main
四、实验步骤与算法实现 #in clude
数据结构---三元组顺序表------稀疏矩阵的转置和快速转置
数据结构---三元组顺序表------稀疏矩阵的转置和快速转置 #include<> #include<> #include<> #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INEEASLIBE -1 #define OVERFLOW -2 #define maxsize 100 typedef int status; typedef int elemtype; typedef struct { int i,j; elemtype e; }elem; typedef struct { elem data[maxsize+1]; int mu,mn,tu; }matrix; status showmatrix(matrix M) { int i,j,k=1; for(i=1;i<=;i++) { for(j=1;j<=;j++) { if(i==[k].i&&j==[k].j) { printf("%d\t",[k].e); k++; } else printf("0\t");
} printf("\n"); } return OK; } status trans(matrix M,matrix &T) { int i=1,j=1,k=1; =; =; =; while(i<= { for(;k<=;k++) if[k].j==i) { [j].e=[k].e; [j].i=[k].j; [j].j=[k].i; j++; } k=1; i++; } return OK; } status initmatrix(matrix &M) { printf("请输入该矩阵行数mu和列数mn和非零元个数tu\nmu="); scanf("%d",&; getchar(); printf("\nmn="); scanf("%d",&; getchar(); printf("\ntu="); scanf("%d",&; getchar(); if>maxsize) { printf("非零元个数已超过定义的值\n请重新输入tu="); scanf("%d",&; getchar();
线性表的顺序存储结构定义和基本操作算法实现
#include "" /***********************线性表的顺序存储结构定义*******************/ #define MAX 11 /*线性表可能达到的最大长度值*/ typedef int datatype; typedef struct {datatype data[MAX]; int last;}list; /************************1.线性表的初始化***************************/ void init(list *lp) {lp->last=0;} /************************2.求线性表的长度***************************/ int length(list *lp) { return (lp->last);} /***************3.插入运算,在表第i个位置插入一个值为 x的新元素******/ void insert(list *lp,int i,datatype x) { int j; if(lp->last==MAX-1) printf("Overflow!\n"); /*表已满*/ else if(i<1||i>lp->last+1) printf("Error!\n"); /*插入位置错误*/ else {for(j=lp->last;j>=i;j--) lp->data[j+1]=lp->data[j]; /*数据元素后移*/ lp->data[i]=x; /*插入x */ lp->last++; /*表长度加1*/ } } /***************4.删除运算,在表中删除第i个数据元素***************/ void delete(list *lp,int i) { int j; if(i<1||i>lp->last) /*检查空表及删除位置的合法性*/ printf("The %dth element is not exist!",i); /*不存在第i个元素*/ else {for(j=i+1;j<=lp->last;j++) lp->data[j-1]=lp->data[j]; /*向前移动元素*/ lp->last--; /*表长度减1 */ } } /*****************5.查找运算,在表中查找x数据元素*****************/ int locate(list *lp,datatype x) { int i=lp->last; while(i>0 && lp->data[i]!=x)i--; return i; }
顺序存储结构的线性表
顺序存储结构的线性表 线性表是最常用且比较简单的一种结构，它是由有限个数据元素组成的有序集合，每个数据元素有一个数据项或者含多个数据项。例如26个英文字母表（A，B，……Z）是一个线性表，表中每一个数据元素由单个字母组成数据项。又如表5.0.1也是一个线性表，表中含八个数据元素，每一个数据元素由n个选手在该项目的竞赛成绩组成。 线性表具有如下结构特征： （1）均匀性。即同一线性表的名数据元素的数据类型一致且数据项相同。 （2）有序性。表中数据元素之间的相对位置是线性的，即存在性一的“第一个”和“最后一个”数据元素。除第一个 和最后一个外，其他元素前面均只有一个数据元素（直接前趋）和后面均只有一个数据元素（直接后继）。 按照表中数据元素的存储方式分顺序存储结构和链式存储结构两类线性表。 1、序存储结构 顺序存储结构是指用一组地址连续的存储单元依次线性表的元素，通常用数组实现。数组的物理实现是一块连续的存储空间，它是按首址（表中第1个元素的地址）+位移来访问每一个元素。 设 loc(a[i])-----A数组中元素i的内存地址(c<=i<=d);
loc(b[i,j])----Bo数组中（i,j）元素的内存地址 (c1<=I<=d1,c2<=j<=d2); loc(a[i])=loc(a[c])+(i-c)*la，la-------atype类型的长度； loc(b[i,j]=loc(b[c1,c2])+((d2-c2+1)*(i-c1)+(j-c2))*lb，lb----atype 类型长度； 一维数组按照下标递增的顺序访问表中元素； a[c]->a[c+1]->……->a[d] 二维数按照先行后列的顺序访问表中元素： b[c1,c2]->b[c1,c+1]->……b[c1,d2]->……>b[i-1,d2]->b[i,c2]-> ……->b[d1,d2-1]->b[d1,d2] 在数组中，数据元素的下标间接反映了数据据元素的存储地址。而计算机内存是随机存储取的装置，所以在数组中存取一个数据元素只要通过下标计算它的存储地址就行了，数组中任意一个元素的存取时间都相等。从这个意义上讲，数组的存储存储结构是一个随机存取的结构。 问题是，虽然数组的顺序分配结构比较简单，便于随机访问数组中的任一元素。但如果数组要保持线性表的特征的话（由下标指明元素间的有序性），其增删操作的效率比较低。特别，当数组很大时，插入与删除运算颇为费时。因此，比较小的数组或元素不常变（很少进行插入与删除运算）的数组可用作线性表，而对于大的线性表或元素经常变动的线性表，可以采链式存储结构。 2、链式存储结构
线性表顺序存储实现、插入、删除操作
#include
相关文档
- 数据结构实现顺序表各种基本运算
- 数据结构顺序表的实现的课程设计报告
- 数据结构实现顺序表的各种基本运算
- 数据结构实现顺序表的各种基本运算
- 数据结构C语言版实验一 顺序表的基本运算
- 数据结构实验报告——顺序表链表的实现
- 《数据结构》实验1
- 数据结构与算法-实现顺序表的基本操作
- 数据结构实验一顺序表的实现和应用
- 数据结构实验一 顺序表的实现
- 数据结构_顺序表的查找实验报告
- 数据结构实现顺序表的各种基本运算(20210215233821)
- 数据结构顺序表实验报告
- 数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现
- 数据结构--顺序表的基本操作(C语言实现)
- 数据结构c++实现顺序表
- c语言数据结构顺序表
- 数据结构实验报告-顺序表的创建、遍历及有序合并操作
- 数据结构实验一顺序表的实现
- 数据结构 顺序表的实现