数据结构实现顺序表各种基本运算

实现顺序表的各种基本运算

一、实验目的

了解顺序表的结构特点及有关概念，掌握顺序表的各种基本操作算法思想及其实现。

二、实验内容

编写一个程序，实现顺序表的各种基本运算：

1、初始化顺序表；

2、顺序表的插入；

3、顺序表的输出；

4、求顺序表的长度

5、判断顺序表是否为空；

6、输出顺序表的第i位置的个元素；

7、在顺序表中查找一个给定元素在表中的位置；

8、顺序表的删除；

9、释放顺序表

三、算法思想与算法描述简图

主函数main void InitList(SqList*&L) 初始化顺序表

void DestroyList(SqList*&L)//释放顺序表L

int ListEmpty(SqList*L)//判断顺序表L是否为空集

int Listlength(SqList*L)//返回顺序表L的元素个数

void DispList(SqList*L)//输出顺序表L

int GetElem(SqList*L,int i,char e)/*ElemType e)获取

顺序表L中的第i个元素*/

int LocateEmpty(SqList*L,char e)/*ElemType e)在顺序

表L中查找元素e*/

int ListInsert(SqList*&L,int i,char e)/*ElemType e)

在顺序表中第i个位置上插入元素e*/

int ListDelete(SqList*&L,int i,char &e)/*ElemType e)

在顺序表L中删除第i个元素*/

四、实验步骤与算法实现

#include

#include

#define MaxSize 50

typedef char ElemType;

typedef struct

{ElemType data[MaxSize];

int length;

}SqList;//顺序表类型的定义

void InitList(SqList*&L)//初始化顺序表L

{L=(SqList*)malloc(sizeof(SqList));

L->length=0;

}

void DestroyList(SqList*&L)//释放顺序表L

{free(L);

}

int ListEmpty(SqList*L)//判断顺序表L是否为空集{return(L->length==0);

}

int Listlength(SqList*L)//返回顺序表L的元素个数{return(L->length);

}

void DispList(SqList*L)//输出顺序表L

{int i;

if(ListEmpty(L))return;

for(i=0;ilength;i++)

printf("%c",L->data[i]);

printf("\n");

}

int GetElem(SqList*L,int i,ElemType e)/*获取顺序表L中的第i个元素*/

{if(i<1||i>L->length)//查找是否有这个i，若没有返回0

return 0;

e=L->data[i-1];

return 1;

}

int LocateEmpty(SqList*L,ElemType e)/*在顺序表L中查找元素e*/

{int i=0;

while (ilength&&L->data[i]!=e)

i++;

if(i>=L->length)

return 0;

else

return i+1;

}

int ListInsert(SqList*&L,int i,ElemType e)/*在顺序表中第i个位置上插入元素e*/ {int j;

if(i<1||i>L->length+1)

return 0;

i--;//将顺序表位序转化为data下标

for(j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置

L->data[j]=L->data[j-1];

L->data[i]=e;

L->length++;//顺序表度增1

return 1;

}

int ListDelete(SqList*&L,int i,ElemType e)/*在顺序表L中删除第i个元素*/

{int j;

if(i<1||i>L->length)

return 0;

i--;//将顺序表位序转化为data下标

e=L->data[i];

for(j=i;jlength-1;j++)

L->data[j]=L->data[j+1];

L->length--;

return 1;

}

void main()

{SqList*L;

ElemType e;

printf("(1)初始化顺序表L\n");

InitList(L);//初始化

printf("(2)依次采用尾插法插入7,9,12,13,14,15,18\n"); ListInsert(L,1,'7');

ListInsert(L,2,'9');

ListInsert(L,3,'12');

ListInsert(L,4,'13');

ListInsert(L,5,'14');

ListInsert(L,6,'15');

ListInsert(L,7,'18');

printf("(3)输出顺序表L:");

DispList(L);

printf("(4)顺序表L长度=%d\n",Listlength(L));

printf("(5)顺序表L为%s\n",(Listlength(L)?"空":"非空")); GetElem(L,3,12);

printf("(6)顺序表第3个元素=%d\n",12);

printf("(7)元素a的位置=%d\n",LocateEmpty(L,'a'));

printf("(8)在第4个数位置上插入8元素\n");

ListInsert(L,4,'8');

printf("(9)输出顺序表L:");

DispList(L);

printf("(10)删除L的第3个元素\n");

ListDelete(L,3,e);

printf("(11)输出顺序表L:");

DispList(L);

printf("(12)释放顺序表L\n");

DestroyList(L);

}

五、实验测试及结果

六、思考题

按由表头至表尾与表尾至表头的次序输入数据元素，则顺序表建立的程序设计有何区别？

解答：若是按表头至表尾次序输入，则存放的元素与顺序表中位置一一对应，而表尾至表头输入则相反。输出时，也相反！

数据结构顺序表真题

第二章复习题 本章重点掌握：线性结构特点，顺序存储结构和链式存储结构特点。 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 )

数据结构实验报告——顺序表链表的实现

课程名称：数据结构任课教师： 实验题目：线性表的基本操作 实验环境： 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)删除指定位置的学生记录;

数据结构与算法基础知识总结

数据结构与算法基础知识总结 1 算法 算法：是指解题方案的准确而完整的描述。 算法不等于程序，也不等计算机方法，程序的编制不可能优于算法的设计。 算法的基本特征：是一组严谨地定义运算顺序的规则，每一个规则都是有效的，是明确的，此顺序将在有限的次数下终止。特征包括： （1）可行性； （2）确定性，算法中每一步骤都必须有明确定义，不充许有模棱两可的解释，不允许有多义性； （3）有穷性，算法必须能在有限的时间内做完，即能在执行有限个步骤后终止，包括合理的执行时间的含义； （4）拥有足够的情报。 算法的基本要素：一是对数据对象的运算和操作；二是算法的控制结构。 指令系统：一个计算机系统能执行的所有指令的集合。 基本运算和操作包括：算术运算、逻辑运算、关系运算、数据传输。 算法的控制结构：顺序结构、选择结构、循环结构。 算法基本设计方法：列举法、归纳法、递推、递归、减斗递推技术、回溯法。 算法复杂度：算法时间复杂度和算法空间复杂度。 算法时间复杂度是指执行算法所需要的计算工作量。 算法空间复杂度是指执行这个算法所需要的内存空间。 2 数据结构的基本基本概念 数据结构研究的三个方面： （1）数据集合中各数据元素之间所固有的逻辑关系，即数据的逻辑结构； （2）在对数据进行处理时，各数据元素在计算机中的存储关系，即数据的存储结构；（3）对各种数据结构进行的运算。 数据结构是指相互有关联的数据元素的集合。 数据的逻辑结构包含： （1）表示数据元素的信息； （2）表示各数据元素之间的前后件关系。 数据的存储结构有顺序、链接、索引等。 线性结构条件：

（1）有且只有一个根结点； （2）每一个结点最多有一个前件，也最多有一个后件。 非线性结构：不满足线性结构条件的数据结构。 3 线性表及其顺序存储结构 线性表由一组数据元素构成，数据元素的位置只取决于自己的序号，元素之间的相对位置是线性的。 在复杂线性表中，由若干项数据元素组成的数据元素称为记录，而由多个记录构成的线性表又称为文件。 非空线性表的结构特征： （1）且只有一个根结点a1，它无前件； （2）有且只有一个终端结点an，它无后件； （3）除根结点与终端结点外，其他所有结点有且只有一个前件，也有且只有一个后件。结点个数n称为线性表的长度，当n=0时，称为空表。 线性表的顺序存储结构具有以下两个基本特点： （1）线性表中所有元素的所占的存储空间是连续的； （2）线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。 ai的存储地址为：adr(ai)=adr(a1)+(i-1)k,，adr(a1)为第一个元素的地址，k代表每个元素占的字节数。 顺序表的运算：插入、删除。（详见14--16页） 4 栈和队列 栈是限定在一端进行插入与删除的线性表，允许插入与删除的一端称为栈顶，不允许插入与删除的另一端称为栈底。 栈按照“先进后出”（filo）或“后进先出”（lifo）组织数据，栈具有记忆作用。用top表示栈顶位置，用bottom表示栈底。 栈的基本运算：（1）插入元素称为入栈运算；（2）删除元素称为退栈运算；（3）读栈顶元素是将栈顶元素赋给一个指定的变量，此时指针无变化。 队列是指允许在一端（队尾）进入插入，而在另一端（队头）进行删除的线性表。rear指针指向队尾，front指针指向队头。 队列是“先进行出”（fifo）或“后进后出”（lilo）的线性表。 队列运算包括（1）入队运算：从队尾插入一个元素；（2）退队运算：从队头删除一个元素。循环队列：s=0表示队列空，s=1且front=rear表示队列满

数据结构- 顺序表的基本操作的实现-课程设计-实验报告

顺序表的基本操作的实现 一、实验目的 1、掌握使用VC++上机调试顺序表的基本方法； 2、掌握顺序表的基本操作：建立、插入、删除等运算。 二、实验仪器 安装VC++软件的计算机。 三、实验原理 利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容 程序中演示了顺序表的创建、插入和删除。 程序如下： #include #include /*顺序表的定义：*/ #define ListSize 100 typedef struct { int data[ListSize]; /*向量data用于存放表结点*/ i nt length; /*当前的表长度*/ }SeqList; void main() { void CreateList(SeqList *L,int n); v oid PrintList(SeqList *L,int n); i nt LocateList(SeqList *L,int x); v oid InsertList(SeqList *L,int x,int i); v oid DeleteList(SeqList *L,int i); SeqList L;

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;

基本数据结构及其运算习题

第二章基本数据结构及其运算 一、单项选择题 1．数据的基本单位是( B ) A．数据B．数据元素C．数据项D．数据结构 2．在数据结构中，构成数据元素的最小单位称为（D）A．字符B．关键字C．数据元素 D．数据项 3．数据在计算机内的存储形式称为数据的（ D ）A．算法描述B．数据类型 C．逻辑结构D．物理结构 4．数据的逻辑结构可分为（C） A．顺序结构和链式结构B．简单结构和复杂结构C．线性结构和非线性结构D．动态结构和静态结构5．顺序表中的每个元素占m个字节，第一个元素的存储地址为LOC(1)，则任意1个元素i的地址为( B ) A．LOC(1)+i*m B．LOC(1)+(i-1)*m C．LCO(1)+(i+1)*m D．(i-1)*m 6．线性表若采用链表存储，其（D） A．所有结点的地址必须是连续的 B．部分结点的地址必须是连续的 C．所有结点的地址一定不连续 D．所有结点的地址连续、不连续都可以 7．线性表在采用链式存储时，其地址（ C ）A．必须是连续的B．一定是不连续的 C．连续不连续都可以D．部分是连续的

8．下列不属于线性结构的是( C )。 A．单链表B．队列 C．二叉树D．数组 9．链表不具有的特点是( A) A．可随机访问任一元素B．插入删除不需要移动元素 C．不必事先估计存储空间D．所需空间与线性表的长度成正比 10．数据结构反映了数据元素之间的结构关系，链表是一种( D)。 A．顺序存储线性表B．非顺序存储非线性表 C．顺序存储非线性表D．非顺序存储线性表 11．在单链表表示的线性表中，可以从( A )。 A．第一个结点访问到所有结点 B．某个结点访问到所有结点 C．某个结点访问到该结点的所有前趋结点 D．最后一个结点访问到所有结点 12．在一个单链表中，已知指针q所指向的结点是指针p所指向的结点的前驱结点，若在指针q和p所指向的两个结点之间插入指针s指向的结点，则执行( C )。 A．s->link=p->link; p->link=s; B．p->link=s->link; s->link=p; C．q->link=s; s->link=p; D．p->link=s; s->link=q; 13．长度为n的顺序存储的线性表，设在任何位置上删除一个元素的概率相等，则删除一个元素时平均要移动的元素

线性表顺序存储结构上的基本运算

实验项目名称：线性表的顺序存储结构上的基本运算 （所属课程：数据结构--用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 typedef int Elemtype; typedef struct{ Elemtype elem[100]; int last; }SeqList; int Locate(SeqList L,Elemtype e){ int i; i=0;

数据结构实现顺序表的各种基本运算(20210215233821)

实现顺序表的各种基本运算 一、实验目的 了解顺序表的结构特点及有关概念，掌握顺序表的各种基本操作算法思想及其实现。 二、实验内容 编写一个程序，实现顺序表的各种基本运算： 1、初始化顺序表； 2 、顺序表的插入； 3、顺序表的输出； 4 、求顺序表的长度 5 、判断顺序表是否为空； 6 、输出顺序表的第i位置的个元素； 7 、在顺序表中查找一个给定元素在表中的位置； 8、顺序表的删除； 9 、释放顺序表 三、算法思想与算法描述简图

主函数main

四、实验步骤与算法实现 #in clude #in clude #defi ne MaxSize 50 typedef char ElemType; typedef struct {ElemType data[MaxSize]; in t le ngth; void In itList(SqList*&L)〃 初始化顺序表 L {L=(SqList*)malloc(sizeof(SqList)); L->le ngth=0; for(i=0;ile ngth;i++) prin tf("%c ",L->data[i]); } void DestroyList(SqList*&L)〃 {free(L); } int ListEmpty(SqList*L)〃 {retur n( L->le ngth==O); } int Listle ngth(SqList*L)〃 {return(L->le ngth); } void DispList(SqList*L)〃 {int i; 释放顺序表 L

数据结构顺序表的实现

实验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);

(完整版)非常实用的数据结构知识点总结

数据结构知识点概括 第一章概论 数据就是指能够被计算机识别、存储和加工处理的信息的载体。 数据元素是数据的基本单位，可以由若干个数据项组成。数据项是具有独立含义的最小标识单位。 数据结构的定义： ·逻辑结构：从逻辑结构上描述数据，独立于计算机。·线性结构：一对一关系。 ·线性结构：多对多关系。 ·存储结构：是逻辑结构用计算机语言的实现。·顺序存储结构：如数组。 ·链式存储结构：如链表。 ·索引存储结构：·稠密索引：每个结点都有索引项。 ·稀疏索引：每组结点都有索引项。 ·散列存储结构：如散列表。 ·数据运算。 ·对数据的操作。定义在逻辑结构上，每种逻辑结构都有一个运算集合。 ·常用的有：检索、插入、删除、更新、排序。 数据类型：是一个值的集合以及在这些值上定义的一组操作的总称。 ·结构类型：由用户借助于描述机制定义，是导出类型。 抽象数据类型ADT：·是抽象数据的组织和与之的操作。相当于在概念层上描述问题。 ·优点是将数据和操作封装在一起实现了信息隐藏。 程序设计的实质是对实际问题选择一种好的数据结构，设计一个好的算法。算法取决于数据结构。 算法是一个良定义的计算过程，以一个或多个值输入，并以一个或多个值输出。 评价算法的好坏的因素：·算法是正确的； ·执行算法的时间； ·执行算法的存储空间（主要是辅助存储空间）； ·算法易于理解、编码、调试。 时间复杂度：是某个算法的时间耗费，它是该算法所求解问题规模n的函数。 渐近时间复杂度：是指当问题规模趋向无穷大时，该算法时间复杂度的数量级。 评价一个算法的时间性能时，主要标准就是算法的渐近时间复杂度。 算法中语句的频度不仅与问题规模有关，还与输入实例中各元素的取值相关。 时间复杂度按数量级递增排列依次为：常数阶O（1）、对数阶O（log2n）、线性阶O（n）、线性对数阶O（nlog2n）、平方阶O （n^2）、立方阶O（n^3）、……k次方阶O（n^k）、指数阶O（2^n）。

实现顺序表各种基本运算的算法

实现顺序表各种基本运算的算法 要求：编写一个程序（algo2_1.cpp）实现顺序表的各种基本操作，并在此基础上设计一个主程序（exp2_1.cpp）完成如下功能： （1）初始化顺序表L （2）依次采用尾插法插入a,b,c,d,e元素 （3）输出顺序表L （4）输出顺序表L的长度 （5）判断顺序表L是否为空 （6）输出顺序表L的第3个元素 （7）输出元素a的位置 （8）在第4个元素位置上插入f元素 （9）输出顺序表L （10）删除L的第3个元素 （11）输出顺序表L （12）释放顺序表L /*文件名:exp2-1.cpp*/ #include #include #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; int length; } SqList; extern void InitList(SqList *&L); extern void DestroyList(SqList *L); extern int ListEmpty(SqList *L); extern int ListLength(SqList *L); extern void DispList(SqList *L); extern int GetElem(SqList *L,int i,ElemType &e); extern int LocateElem(SqList *L, ElemType e); extern int ListInsert(SqList *&L,int i,ElemType e); extern int ListDelete(SqList *&L,int i,ElemType &e); void main() { SqList *L; ElemType e; printf("(1)初始化顺序表L\n"); InitList(L); printf("(2)依次采用尾插法插入a,b,c,d,e元素\n"); ListInsert(L,1,'a'); ListInsert(L,2,'b');

实验一数据结构顺序表的插入和删除

实验一顺序表的操作 1. 实验题目：顺序表的操作 2.实验目的和要求： 1)了解顺 序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、 删除、查找以及线性表合并 )。 2)通过在 Turbo C ( WinTc ，或 visual stdio6 )实现以上操作的 C 语言 代码。 3)提前了解实验相关的知识(尤其是 C 语 言)。 3.实验内容：(二选一) 1) 顺序表的插入算法, 删除算法, 顺序表的合并算法 2) 与线性表应用相关的实例( 自己选择具体实例) 4.部分参考实验代码： ⑴ 顺序表结构的定义： #include #define MAXLEN 255 typedef int ElemType; typedef struct { ElemType elem[MAXLEN]; int length; }sqList; ⑵ 顺序表前插(在第i 号元素前插入一个新的元素) int ListInsert(sqList *la,int i,int x) { int j; if(i<0||i>la-> length +1) { printf( “ n the value of i is wrong! ” ); return 0; } if(la-> length +1>=MAXLEN) { printf( “ n overflow! ” ); return 0; }

. for(j=la-> length;j>=i;j--) la->list[j+1]=la->list[j]; la->list[i]=x; la-> length ++; return 1; } ⑶ 顺序表删除 int ListDelete(sqList *la,int i) { if(i<0||i>la-> length ) { printf( “ return 0; n”); } for(i;i length;i++) la->list[i-1]=la->list[i]; la-> length --; return 1; } 5.附录：实验预备知识： ⑴ 复习 C 语言中数组的用法。 ⑵ 了解线性表和顺序表的概念，顺序表的定义方法； 线性表是n 个数据元素的有限序列，至于每个数据元素的具体含义，在不同的情况下各不相同。 顺序表是线性表的顺序存储表示，是用一组地址连续的存储单元依次存储线性表的数据元素。 在 C 语言中，顺序表是用数组来实现的。 ⑶ 掌握线性表在顺序存储结构上实现基本操作：查找、插入、删除和 合并的算法。 在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容： 在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果（查到时输出查到的数据，未查到时给出未查到提 示）。 在实现插入的时候，首先要判断该顺序表是否为满，如为满则报错 （此时要注意：顺序表是用数组来实现的，它不能随机分配空 间）；如不为满，则需判断要插入的位置是否合法（例如：如果 一个线性表的元素只有10 个，而要在第0 个元素前插入或在第 11 个元素后插入就为不合法）。其次要注意是前插还是后插，两

数据结构C语言版 串的定长顺序存储表示和实现

#include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define MAXSTRLEN 255 typedef int ElemType; typedef int Status; typedef unsigned char SString[MAXSTRLEN+1]; //串赋值操作 Status StrAssign(SString T,char chars[]){ // 生成一个其值等于chars的串T int i; if(strlen(chars)>MAXSTRLEN) return ERROR; T[0]=strlen(chars); for(i=0;i<=T[0];i++){ T[i+1]=chars[i];} return OK; }//StrAssign //输出串 void StrPrint(SString S){ int i; for(i=1;i<=S[0];i++){ printf("%c",S[i]); } printf("\n"); }//PrnStr //串复制操作 Status StrCopy(SString T,SString S){ // 由串S复制得串T int i; for(i=1;i<=S[0];i++) T[i]=S[i]; T[0]=S[0]; return OK; }//StrCopy //判空操作 Status StrEmpty(SString S){ if(S[0]==0) return OK;

数据结构实验报告-顺序表的创建、遍历及有序合并操作

数据结构实验报告-顺序表的创建、遍历及有序合并操作二、实验内容与步骤 实现顺序表的创建、遍历及有序合并操作，基本数据结构定义如下： typedef int ElemType; #define MAXSIZE 100 #define FALSE 0 #define TRUE 1 typedef struct {ElemType data[MAXSIZE]; int length; }seqlist; 创建顺序表，遍历顺序表 #include #include #define MAXSIZE 100 #define Icreament 20 #define FALSE 0

#define TRUE 1 typedef int ElemType; //用户自定义数据元素类型 // 顺序表结构体的定义 typedef struct { ElemType *elem; //顺序表的基地址 int length; //顺序表的当前长度 int listsize; //预设空间容量 }SqList; //线性表的顺序存储结构 SqList* InitList() //创建空的顺序表 { SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表L if(!L) { printf("空间划分失败，程序退出\n"); return NULL; } L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType)); if(!L->elem) { printf("空间划分失败，程序退出\n");

数据结构的逻辑结构、存储结构及数据运算的含义及其相互关系

2007 C C C 语言的特点，简单的C 程序介绍，C 程序的上机步骤。1 、算法的概念2、简单的算法举例3、算法的特性4、算法的表示（自然语言、流程图、N-S 图表示） 1 、 C 的数据类型、常量与变星、整型数据、实型数据、字符型数据、字符串常量。2、 C 的运算符运算意义、优先级、结合方向。3、算术运算符和算术表达式，各类数值型数据间的混合运算。4、赋值运算符和赋值表达式。5、逗号运算符和逗号表达式。 1 、程序的三种基本结构。2、数据输入输出的概念及在C 语言中的实现。字符数据的输入输出，格式输入与输出。 1 、关系运算符及其优先级，关系运算和关系表达式。2、逻辑运算符及其优先级，逻辑运算符和逻辑表达式。3、if语句。if语句的三种形式，if语句的嵌套，条件运算符。4、switch 语句. 1 、while 语句。2、do/while 语句。3、for 语句。4、循环的嵌套。5、break 语句和continue 语句。1 、一维数组的定义和引用。2、二维数组的定义和引用。3、字符数组。4、字符串与字符数组。5、字符数组的输入输出。6、字符串处理函数1 、函数的定义。2、函数参数和函数的值，形式参数和实际参数。3、函数的返回值。4、函数调用的方式，函数的声明和函数原型。5、函数的嵌套调用。 6、函数的递归调用。 7、数组作为函数参数。 8、局部变量、全局变量的作用域。 9、变量的存储类别，自动变星，静态变量。1 、带参数的宏定义。2、“文件包含”处理。1 、地址和指针的概念。2、变量的指针和指向变量的指针变量。3、指针变量的定义

和引用。4、指针变量作为函数参数。5、数组的指针和指向数组的指针变量。6、指向数组元素的指针。7、通过指针引用数组元素。8、数组名作函数参数。9、二维数组与指针。 1 0、指向字符串的指针变星。字符串的指针表示形式，字符串指针作为函数参数。11 、字符指针变量和字符数组的异同。1 2、返回指针值的函数。1 3、指针数组。1 、定义结构体类型变星的方法。2、结构体变量的引用。3、结构体变量的初始化。4、结构体数组5、指向结构体类型数据的指针。6、共用体的概念，共用体变量的定义和引用，共用体类型数据的特点。typedef 1 、数据结构的逻辑结构、存储结构及数据运算的含义及其相互关系。2、数据结构的两大类逻辑结构和常用的存储表示方法。3、算法描述和算法分析的方法，对于一般算法能分析出时间复杂度。 1 、线性表的逻辑结构特征。2、线性表上定义的基本运算。3、顺序表的特点，即顺序表如何反映线性表中元素之间的逻辑关系。4、顺序表上的插入、删除操作及其平均时间性能分析。5、链表如何表示线性表中元素之间的逻辑关系。6、链表中头指针和头结点的使用。7、单链表上实现的建表、查找、插入和删除等基本算法，并分析其时间复杂度。8、顺序表和链表的主要优缺点。9、针对线性表上所需的主要操作，选择时空性能优越的存储结构。 1 、栈的逻辑结构特点．栈与线性表的异同。2、顺序栈和链栈实现的进栈、退栈等基本算法。3、栈的空和栈满的概念及其判定条件。4、队列的逻辑结构特点，队列与线性表的异同。5、顺序队列(主要是循

数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作 一、实验目的 掌握线性表的顺序表基本操作：建立、插入、删除、查找、合并、打印等运算。 二、实验要求包含有头文件和main函数； 1.格式正确，语句采用缩进格式； 2.设计子函数实现题目要求的功能； 3.编译、连接通过，熟练使用命令键； 4.运行结果正确，输入输出有提示，格式美观。 三、实验设备、材料和工具 1.奔腾2计算机或以上机型 2.turboc2,win-tc 四、实验内容和步骤 1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 2. 往该顺序表中第i位置插入一个值为x的数据元素。 3. 从该顺序表中第j位置删除一个数据元素，由y返回。 4. 从该顺序表中查找一个值为e的数据元素，若找到则返回该数据元素的位置，否则返回“没有找到”。 五、程序 #include #include #define list_init_size 10 #define increment 2

typedef struct { int *elem; int length,listsize; }sqlist; //类型定义 void initlist_sq(sqlist &L) //初始化顺序表 { } void output(sqlist L) //输出顺序表 { } void insertlist(sqlist &L,int i, int x) //顺序表中插入x { } void deletelist(sqlist &L,int j, int y) //顺序表中删除y { } int locateelem(sqlist &L,int e) //顺序表中查找e { } void main() { } 【运行结果】 void initlist_sq(sqlist &L) //初始化顺序表 { L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int)); if(!L.elem) exit (OVERFLOW);

数据结构与算法-实现顺序表的基本操作

实验报告 课程：数据结构与算法实验日期： 实验名称：实现顺序表的基本操作 一、实验目的 实现顺序表的熟练操作 二、实验内容 （1）先给出顺序表的类型定义 （2）给出顺序表的如下基本操作的算法函数定义 a) 构造一个空的线性表：InitList_Sq(SqList &L) b) 在顺序表L的第i个位置之前插入新的元素e：ListInsert_Sq(SqList &L, int i, ElemType e) c) 在顺序表L中删除第i个元素，并用e返回其值：ListDelete_Sq(SqList &L, int i, ElemType &e) （3）实现如下新操作的函数定义： a) 借助ListInsert_Sq操作创建一个顺序表：ListCreate_Sq(???) b) 计算线性表的长度：ListLength_Sq(???) c) 打印顺序表中的所有元素值：ListPrint_Sq(???) 其中???请自行考虑 （4）在主函数中分别调用ListCreate_Sq、ListPrint_Sq 、ListLength_Sq、ListInsert_Sq、ListDelete_Sq等函数，查看这些函数是否正常工作 三、实验步骤 （1）先给出顺序表的类型定义 （2）给出顺序表的如下基本操作的算法函数定义 a) 构造一个空的线性表：InitList_Sq(SqList &L)

b) 在顺序表L的第i个位置之前插入新的元素e：ListInsert_Sq(SqList &L, int i, ElemType e) c) 在顺序表L中删除第i个元素，并用e返回其值：ListDelete_Sq(SqList &L, int i, ElemType &e)

数据结构实验一顺序表的实现

算法分析实验一顺序表的实现 班级学号姓名分数 一、实验目的： 1.掌握线性表的顺序存储结构 2.能熟练地利用顺序存储结构实现线性表的基本操作 3.能熟练地掌握顺序存储结构中算法的实现 二、实验要求 熟悉线形表的基本操作，对线形表能够进行插入、删除、修改、查找等操作。 三、实验内容及分析： 建立含有若干个元素的顺序表，并将结果在屏幕上输出。对刚建立的顺序表实现插入、删除、修改、查找，并将结果在屏幕上输出。 内容分析：先建立一个顺序表，定义表的最大长度为100，程序可以实现输出、查找、插入、删除操作。先定义一个整型变量i，用于初始线性表的长度，再输入所有元素，选择菜单里的选项实现功能。插入：选择需插入元素的位置，插入位置及后面的元素后移一位，再插入元素；删除：选择要删除元素的位置，将要删除的元素移出顺序表，删除位置后的元素前移一位；查找：输入要查找的元素，按顺序查找，当查找到顺序表的第一个与要查找的元素相同时，输出结果。 四、程序的调试及运行结果

五、程序代码 #include using namespace std; const int Max=100; <

initial(s); 示所有元素. " <>j; switch(j) { case '1':print(s);break; 2 a <>loc; //输入要删除的元素的位置 temp=del(s,loc,ch); //删除检查 if(temp==true) cout <<"删除了一个元素: " <>ch; //输入要查找的元素 loc=locate(s,ch); //寻找元素的位置 if(loc!=-1) { cout <<"该元素所在位置: " ; cout <<(loc+1) <

数据结构线性表的顺序表示和实现(C语言)概论

/* 线性结构，线性表的顺序表示和实现 */ # include # include # include //包含了exit（）函数 //定义一个数组结构体 struct Arr { int * pBase; //保存数组的指针 int len; //保存数组的长度 int cnt; //数组元素的有效个数 }; //前置函数声明 void init_arr(struct Arr * pArr,int length); //初始化 bool append_arr(struct Arr * pArr,int val); //追加一个元素 bool insert_arr(struct Arr * pArr, int pos, int val); //插入一个元素 bool delete_arr(struct Arr * pArr, int pos, int * val); //删除数组中的一个元素int get(struct Arr * pArr, int pos); //获取某个元素的值 bool is_empty(struct Arr * pArr); //判断数组是否为空 bool is_full(struct Arr * pArr); //判断数组是否已满 void sort_arr(struct Arr * pArr); //为数组进行从小到大排序 void show_arr(struct Arr * pArr); //显示数组内容 void inversion_arr(struct Arr * pArr); //反转数组中的所有值 /* 创建一个数组，实现对这个数组的操作 1，追加一个元素 2，插入一个元素 3，对数组排序 4，反转数组元素 */ int main(void) { //定义一个结构体变量 struct Arr array; //获取一个被删除的元素的值 int val; //使用函数init_arr()初始化数组 init_arr(&array, 5);