数据结构实验要求

实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。

2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。

3熟悉VC++程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。

4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。

加强、提高题：2、编写一个求解Josephus问题的函数。

用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。

然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。

最后分析所完成算法的时间复杂度。

定义JosephusCircle类，其中含完成初始化、报数出圈成员函数、输出显示等方法。

（可以选做其中之一）加强题：（1）采用数组作为求解过程中使用的数据结构。

提高题：（2）采用循环链表作为求解过程中使用的数据结构。

运行时允许指定任意n、s、m数值，直至输入n = 0退出程序。

实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题（必做）：1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。

2、假设以带头结点的循环链表表示队列，并且只设一个指针指向对尾结点，不设头指针，试设计相应的置队空、入队和出队的程序。

加强题：3设线性表A中有n个字符，试设计程序判断字符串是否中心对称，例如xyzyx和xyzzyx都是中心对称的字符串。

数据结构实验指导书一、实验目的数据结构是计算机科学中的重要基础课程，通过实验，旨在帮助学生更好地理解和掌握数据结构的基本概念、原理和算法，提高学生的编程能力和问题解决能力。

具体而言，实验的目的包括：1、加深对常见数据结构（如数组、链表、栈、队列、树、图等）的理解，掌握其特点和操作方法。

2、培养学生运用数据结构解决实际问题的能力，提高算法设计和程序实现的能力。

3、增强学生的逻辑思维能力和调试程序的能力，培养学生的创新意识和团队合作精神。

二、实验环境1、操作系统：Windows 或 Linux 操作系统。

2、编程语言：C、C+＋、Java 等编程语言中的一种。

3、开发工具：如 Visual Studio、Eclipse、Code:：Blocks 等集成开发环境（IDE）。

三、实验要求1、实验前，学生应认真预习实验内容，熟悉相关的数据结构和算法，编写好实验程序的代码框架。

2、实验过程中，学生应独立思考，认真调试程序，及时记录实验过程中出现的问题及解决方法。

3、实验完成后，学生应撰写实验报告，包括实验目的、实验内容、实验步骤、实验结果、问题分析与解决等。

四、实验内容（一）线性表1、顺序表的实现与操作实现顺序表的创建、插入、删除、查找等基本操作。

分析顺序表在不同操作下的时间复杂度。

2、链表的实现与操作实现单链表、双向链表的创建、插入、删除、查找等基本操作。

比较单链表和双向链表在操作上的优缺点。

（二）栈和队列1、栈的实现与应用实现顺序栈和链式栈。

利用栈解决表达式求值、括号匹配等问题。

2、队列的实现与应用实现顺序队列和链式队列。

利用队列解决排队问题、广度优先搜索等问题。

（三）树1、二叉树的实现与遍历实现二叉树的创建、插入、删除操作。

实现二叉树的前序、中序、后序遍历算法，并分析其时间复杂度。

2、二叉搜索树的实现与操作实现二叉搜索树的创建、插入、删除、查找操作。

分析二叉搜索树的性能。

（四）图1、图的存储结构实现邻接矩阵和邻接表两种图的存储结构。

一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。

为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。

二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。

2. 熟练运用数据结构解决实际问题，提高算法设计能力。

3. 培养团队合作精神，提高实验报告撰写能力。

三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。

（2）实现线性表的插入、删除、查找等操作。

2. 栈与队列（1）实现栈的顺序存储和链式存储。

（2）实现栈的入栈、出栈、判断栈空等操作。

（3）实现队列的顺序存储和链式存储。

（4）实现队列的入队、出队、判断队空等操作。

3. 树与图（1）实现二叉树的顺序存储和链式存储。

（2）实现二叉树的遍历、查找、插入、删除等操作。

（3）实现图的邻接矩阵和邻接表存储。

（4）实现图的深度优先遍历和广度优先遍历。

4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。

（2）实现二分查找算法。

（3）设计并实现一个简单的学生成绩管理系统。

四、实验步骤1. 熟悉实验要求，明确实验目的和内容。

2. 编写代码实现实验内容，对每个数据结构进行测试。

3. 对实验结果进行分析，总结实验过程中的问题和经验。

4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。

五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。

（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。

2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。

（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。

3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。

数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。

具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。

2、理解栈和队列的特性，并能够实现其基本操作。

3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。

4、学会使用图的数据结构，并实现图的遍历和相关算法。

二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。

三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。

实现顺序表的初始化、插入、删除和查找操作。

2、链表的实现定义链表的节点结构，包含数据域和指针域。

实现链表的创建、插入、删除和查找操作。

（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。

实现栈的入栈、出栈和栈顶元素获取操作。

2、队列的实现采用循环队列的方式实现队列的数据结构。

完成队列的入队、出队和队头队尾元素获取操作。

（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。

2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。

3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。

（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。

删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。

2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。

（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。

入栈和出栈操作的时间复杂度均为 O(1)。

2、队列队列的特点是先进先出，常用于排队、任务调度等场景。

数据结构实验课教案一、实验目的与要求1. 实验目的(1) 掌握数据结构的基本概念和算法。

(2) 培养实际操作能力，巩固课堂所学知识。

(3) 提高编程技能，为实际项目开发打下基础。

2. 实验要求(1) 严格按照实验指导书进行实验。

(2) 实验前认真预习，充分理解实验内容。

(3) 实验过程中积极思考，遇到问题及时解决。

(4) 按时完成实验，积极参与讨论与交流。

二、实验环境与工具1. 实验环境(1) 操作系统：Windows 7/8/10或Linux。

(2) 编程语言：C/C++、Java或Python。

(3) 开发工具：Visual Studio、Eclipse、IntelliJ IDEA或PyCharm。

2. 实验工具(1) 文本编辑器或集成开发环境（IDE）。

(2) 版本控制系统（如Git）。

(3) 在线编程平台（如LeetCode、牛客网）。

三、实验内容与安排1. 实验一：线性表的基本操作(1) 实现线性表的顺序存储结构。

(2) 实现线性表的插入、删除、查找等基本操作。

(3) 分析线性表的时间复杂度。

2. 实验二：栈与队列的基本操作(1) 实现栈的顺序存储结构。

(2) 实现队列的顺序存储结构。

(3) 实现栈与队列的进栈、出栈、入队、出队等基本操作。

(4) 分析栈与队列的时间复杂度。

3. 实验三：线性表的链式存储结构(1) 实现单链表的结构。

(2) 实现单链表的插入、删除、查找等基本操作。

(3) 分析单链表的时间复杂度。

4. 实验四：树与二叉树的基本操作(1) 实现二叉树的结构。

(2) 实现二叉树的遍历（前序、中序、后序）。

(3) 实现二叉搜索树的基本操作。

(4) 分析树与二叉树的时间复杂度。

5. 实验五：图的基本操作(1) 实现图的邻接矩阵存储结构。

(2) 实现图的邻接表存储结构。

(3) 实现图的深度优先搜索（DFS）和广度优先搜索（BFS）。

(4) 分析图的时间复杂度。

四、实验评价与成绩评定1. 实验评价(1) 代码质量：代码规范、注释清晰、易于维护。

数据结构实验二数据结构实验二：队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构，加深对队列和栈实现原理的理解，并熟练掌握队列和栈的基本操作。

二、实验要求1.使用C/C++语言实现队列的基本操作：初始化队列、入队、出队、判空、判满等。

2.使用C/C++语言实现栈的基本操作：初始化栈、入栈、出栈、判空、判满等。

3.验证队列和栈的实现是否正确。

4.分析队列和栈的时间复杂度，并给出实验结果。

5.撰写实验报告，包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。

三、实验原理1.队列：队列是一种先进先出(FIF0)的数据结构。

在队列中，数据元素按照进入队列的顺序排列，首元素是最先进入的元素，尾元素是最后进入的元素。

队列的基本操作有：初始化队列、入队、出队、判空、判满等。

2.栈：栈是一种后进先出(LIFO)的数据结构。

在栈中，数据元素按照进入栈的顺序排列，但是只能从栈顶进出，即最后进入的元素最先出栈。

栈的基本操作有：初始化栈、入栈、出栈、判空、判满等。

四、实验步骤1.实现队列的基本操作：1.初始化队列：创建一个空队列，并设置相关指针。

2.入队：将新元素插入到队尾。

3.出队：将队头元素删除，并返回其值。

4.判空：判断队列是否为空。

5.判满：判断队列是否已满。

2.实现栈的基本操作：1.初始化栈：创建一个空栈，并设置相关指针。

2.入栈：将新元素压入栈顶。

3.出栈：将栈顶元素弹出，并返回其值。

4.判空：判断栈是否为空。

5.判满：判断栈是否已满。

3.编写测试代码，验证队列和栈的基本操作是否正确。

4.进行性能测试，分析队列和栈的时间复杂度。

五、实验结果与分析1.队列的时间复杂度：●初始化队列：O(1)●入队：O(1)●出队：O(1)●判空：O(1)●判满：O(1)2.栈的时间复杂度：●初始化栈：O(1)●入栈：O(1)●出栈：O(1)●判空：O(1)●判满：O(1)3.根据实验结果可以看出，队列和栈的基本操作的时间复杂度都是O(1)，即常数时间复杂度，具有高效性。

数据结构实验指导书院别专业班级姓名计算机学院编实验一线性表的顺序存储实验一、实验目的及要求1、掌握在TC环境下调试顺序表的基本方法2、掌握顺序表的基本操作，插入、删除、查找、以及有序顺序表的合并等算法的实现。

二、实验学时2学时三、实验任务1、生成一个顺序表并动态地删除任意元素和在任意位置插入元素。

2、将两个有序表合并成一个有序表。

四、实验重点、难点1、在顺序表中移动元素。

2、在顺序表中找到正确的插入位置。

五、操作要点(一)顺序表基本操作的实现[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时，必须先将顺序表中第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。

若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。

[基本要求] 要求生成顺序表时，可以键盘上读取元素，用顺序存储结构实现存储。

[实现提示] 要实现基本操作，可用实现的基本操作，也可设计简单的算法实现。

[程序实现]#include <stdio.h>#include <conio.h>typedef int DataType ;# define maxnum 20typedef struct{int data[maxnum];int length;}SeqList;/*插入函数*/int insert(SeqList *L , int i , DataType x)/* 将新结点x插入到顺序表L第i个位置 */{ int j ;if( i<0 || i>(*L).length +1){ printf(" \n i 值不合法 ! ");return 0;}if((* L).length >=maxnum-1){ printf(" \n 表满不能插入!");return 0;}for(j=(*L).length;j>=i;j--) (*L).data[j+1]=(*L).data[j];(*L).data[i] = x;(*L).length++;return 1;}/*删除函数*/int delete( SeqList *L ,int i)/*从顺序L中删除第i个结点*/{ int j ;if( i<0|| i>(*L).length ){ printf(" \n 删除位置错误 ! ") ;return 0;}for(j=i+1;j<=(*L).length;j++)(*L).data[j-1] =(*L).data[j];(*L).length--;return 1;}/*生成顺序表*/void creatlist(SeqList * L){ int n , i , j ;printf("请输入顺序表 L 的数据个数：\n") ;scanf("%d" , &n) ;for(i=0 ; i<n ; i++){ printf("data[%d] =" , i) ;scanf("%d",&((*L).data[i]));}(*L).length=n-1;printf("\n") ;}/*creatlist *//*输出顺序表 L*/printout(SeqList * L){ int i ;for (i=0 ; i<=(* L).length ; i++){ printf(" data[%d]=", i) ;printf("%d", (*L).data[i]);}/*printout */printf("\n");}main(){ SeqList *L ;char cmd ;int i , t , x;clrscr() ;creatlist(L);do{printf("\ni , I ----- 插入\n") ;printf("d , D ----- 删除\n") ;printf("q , Q ----- 退出\n") ;do{cmd=getchar() ;}while((cmd!='i')&&(cmd!='I')&&(cmd!='d')&&(cmd!='D')&&(cmd!='q')&&(cmd!='Q')); switch(cmd){ case 'i':case 'I':printf("\nPlease input the DATA: ");scanf("%d",&x) ;printf("\nWhere? ");scanf("%d",&i) ;insert(L,i,x) ;printout(L);break ;case 'd':case 'D' :printf("\nWhere to Delete? ");scanf("%d",&i);delete(L,i);printout(L);break ;}}while((cmd!='q')&&(cmd!='Q'));}（二）有序顺序表的合并[问题描述] 已知顺序表la和lb中的数据元素按非递减有序排列，将la和lb表中的数据元素，合并成为一个新的顺序表lc[基本要求] lc中的数据元素仍按非递减有序排列，并且不破坏la和lb表[程序实现]# include <stdio.h># define maxnum 20typedef int DataType ;typedef struct{ DataType data[maxnum] ;int length ;}SeqList ;int MergeQL(SeqList la , SeqList lb , SeqList *lc){ int i , j , k ;if (la.length+1 + lb.length+1>maxnum){ printf("\narray overflow!") ;return 0;}i=j=k=0;while(i<=la.length && j<=lb.length){ if (la.data[i]<=lb.data[j])lc->data[k++]=la.data[i++] ;elselc->data[k++]=lb.data[j++];}/* 处理剩余部分 */while (i<=la.length) lc->data[k++]=la.data[i++];while (j<=lb.length) lc->data[k++]=lb.data[j++];lc->length=k-1;return 1;}main(){ SeqList la={{3,4,7,12,15},4} ;SeqList lb={{2,5,7,15,18,19},5} ;SeqList lc ;int i ;if (MergeQL(la,lb,&lc)){ printf("\n") ;for(i=0;i<=lc.length ; i++)printf("%4d",lc.data[i]);}}六、注意事项1、删除元素或插入元素表的长度要变化。

一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的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++)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<<"请选择所要取出元素的位置:";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<<"请选择所要取出元素的位置:";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);default : cout<<"输入有误，请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时，我有点惊讶，才学了不到一个月，就要写实验报告。

线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。

（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C语言描述方法。

（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。

（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。

（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

2、实验要求（1）熟悉顺序表的插入、删除和查找。

（2）熟悉单链表的插入、删除和查找。

3、实验内容:①顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize]; //容量为maxsize的静态顺手表int n; //顺序表中的实际元素个数}SeqList; //静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。

（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;n<m;n++){cout<<"请输入线性表数据"<<endl;cin>>[n]; //顺序将数据存入顺序表} //其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L) //插入数据{int a,b,c,k;cout<<"请输入插入的数及其插入的位置"<<endl;cin>>a>>b;if(b<=0||b>+1)) {cout<<"不能在该位置插入"<<endl; return;} //判断插入位置是否合法k=[b-1];[b-1]=a; c=; =+1;while(c>b){[c]=[c-1];c--; //通过循环，实现插入位置后的数据挨个往后移动一位}[b]=k;}顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。

深 圳 大 学 实 验 报 告课程名称： 数据结构实验与课程设计 实验项目名称： 实验一：顺序表的应用 学院： 计算机与软件学院 专业： 指导教师： **报告人： 文成 学号： ********** 班级： 5 实验时间： 2012-9-17实验报告提交时间： 2012-9-24教务部制一、实验目的与要求：目的：1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求：1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容：Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行插入操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行删除操作后，顺序表内的所有数据，数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置，对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据，数据是小于100的正整数第三行输入两个参数，表示要交换的两个位置第四行输入两个参数，表示要交换的两个位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行第一次交换操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行第二次交换操作后，顺序表内的所有数据，数据之间用空格隔开注意加入交换位置的合法性检查，如果发现位置不合法，输出error。