数据结构之顺序表元素查找

实验五查找的应用一、实验目的：1、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。

2、增强上机编程调试能力。

二、问题描述1.分别利用顺序查找和折半查找方法完成查找。

有序表（3,4,5,7,24,30,42,54,63,72,87,95）输入示例：请输入查找元素：52输出示例：顺序查找：第一次比较元素95第二次比较元素87 ……..查找成功，i=**/查找失败折半查找：第一次比较元素30第二次比较元素63 …..2.利用序列（12,7,17,11,16,2,13,9,21,4）建立二叉排序树，并完成指定元素的查询。

输入输出示例同题1的要求。

三、数据结构设计（选用的数据逻辑结构和存储结构实现形式说明）（1）逻辑结构设计顺序查找和折半查找采用线性表的结构，二叉排序树的查找则是建立一棵二叉树，采用的非线性逻辑结构。

（2）存储结构设计采用顺序存储的结构，开辟一块空间用于存放元素。

（3）存储结构形式说明分别建立查找关键字，顺序表数据和二叉树数据的结构体进行存储数据四、算法设计（1）算法列表（说明各个函数的名称，作用，完成什么操作）序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化，并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 （2）各函数间调用关系（画出函数之间调用关系）typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;（3）算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。

一、单选题1、对有14个元素的有序表A[14]作二分查找，查找元素A[3]时，将会与元素依次比较。

A.A[0]，A[1]，A[2]，A[3]B.A[6]，A[2]，A[4]，A[3]C.A[6]，A[4]，A[2]，A[3]D. A[0]，A[13]，A[6]，A[3]正确答案：B2、如果线性表最常用的操作是取第i个结点及其前驱，则采用_____存储方式最节省时间。

A.顺序表B.单向链表C.单向循环链表D.双向链表正确答案：A3、对于顺序存储的长度为n的线性表，在第i个位置插入一个元素需要移动____个元素。

其中，0≤i＜n。

A.n-i+1B.n-iC.iD.n-i-1正确答案：B4、对线性表进行二分查找时，要求线性表必须采用 _____。

A.链式存储，且结点有序排序B.顺序存储，且结点有序排序C.链式存储D.顺序存储正确答案：B5、有一个长度为12的有序表，按二分找法对该表进行查找，在表内各元素等概率情况下查找成功所需的平均比较次数为_____。

A.37/12B.35/12C.39/12D.43/12正确答案：A6、有序数组a[18]进行二分查找时，查找到a[5]的查找路径（下标序列）为_____。

A.8，4，5B.1，3，5C.8，2，5D.8，3，5正确答案：D7、用二分法对数组a[13]进行查找，若待查元素为x，且a[7]<x<a[8]，那么查找路径为____________A.6，9，7B.7，9，8C.6，9，7，8D.6，9，8正确答案：C8、对于顺序存储的长度为n的线性表，删除第i个元素需要移动____个元素。

其中，0≤i＜n。

A.iB.n-i-1C.n-i+1D.n-i正确答案：B9、用二分法对数组a[13]进行查找，在等概率的情况下，查找不成功的平均查找长度为________。

A.49/13B.49/14C.27/7D.54/13正确答案：C10、对a[12]进行二分查找，查找下标为_____的元素时，查找长度最大。

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算2、实验内容：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：∙创建一个新的顺序表，实现动态空间分配的初始化；∙根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；∙根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；∙利用最少的空间实现顺序表元素的逆转；∙实现顺序表的各个元素的输出；∙彻底销毁顺序线性表，回收所分配的空间；∙对顺序线性表的所有元素删除，置为空表；∙返回其数据元素个数；∙按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；∙按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；∙判断顺序表中是否有元素存在，对判断结果进行返回；.编写主程序，实现对各不同的算法调用。

2．实现要求：∙“初始化算法”的操作结果：构造一个空的顺序线性表。

对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；∙“位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；∙“位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；∙“逆转算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序表的元素进行交换；∙“输出算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行输出；∙“销毁算法”初始条件：顺序线性表L 已存在；操作结果：销毁顺序线性表L；∙“置空表算法”初始条件：顺序线性表L 已存在；操作结果：将L 重置为空表；∙“求表长算法”初始条件：顺序线性表L 已存在；操作结果：返回L 中数据元素个数；∙“按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)操作结果：返回L 中第i 个数据元素的值∙“按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；操作结果：返回L 中数据元素值为e 的元素位置；∙“判表空算法”初始条件：顺序线性表L 已存在；操作结果：若L 为空表，则返回TRUE，否则返回FALSE；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。

数据结构顺序查找与折半查找1，顺序查找顺序查找⼜称线性查找，它对顺序表和链表都适⽤。

（1）以下给出相关函数1 typedef struct{2 ElemType *elem; //元素存储空间地址，建表时按实际长度分配，0号单元留空3int TableLen; //表的长度4 }SSTable;5int Search_Seq(SSTable ST,ElemType key)6 {7 ST.elem[0]=key; //把要查找的关键字放在0号位置，称“哨兵”8for(int i=ST.TableLen;ST.elem!=key;i--) //从后往前找9 {10return i; //若表中不存在关键字为key的元素，将查找i=0时退出循环11 }12 }在上述算法中，将ST.elem[0]称为“哨兵”。

引⼊它的⽬的是使得Search_Seq内的循环不必判断数组是否会越界。

因为满⾜i=0时，循环⼀定会跳出。

除此之外，引⼊“哨兵”可以避免很多不必要的判断语句，从⽽提⾼算法的执⾏效率。

（2）算法效率分析当每个元素查找概率相同时，平均查找长度ASL=（n+1)/2, 查找不成功时，需要⽐较整个顺序表，所以⽐较次数时（n+1)次，从⽽顺序查找不成功的平均查找长度为(n+1)。

2.有序表的顺序查找（假设从⼩到⼤排列）有序表的顺序查找成功的平均查找长度与⼀般的线性表⼀样，即（n+1)/2.当查找失败时，待查找的元素为key,当查找第i个元素时，发现第i个元素的对应的关键字⼩于key,但第i+1个元素对应的关键字⼤于key,这时就可以返回查找失败的信息。

查找失败的平均查找长度为ASL=n/2+n/(n+1).3.折半查找前提：折半查找仅适⽤于有序的顺序表。

折半查找原理：将给定的key与中间元素⽐较，直到查到要找的元素。

以下是相关函数1int Binary_Search(SeqList L,ElemType key){2int low=0,high=L.TableLen-1,mid;//low指向表头，high指向表尾，mid中间值3while(low<=high)4 {5 mid=(low+high)/2;6if(L.elem[mid]==key) //中间值等于要查找元素7return mid;8else if(L.elem[mid]<key) //要查找元素在中间值右边9 low=mid+1;10else11 hign=mid-1; //要查找元素在中间值左边12 }13 }查找成功的时间复杂度为log2n，平均情况下⽐顺序查找效率⾼⼀些。

数据结构中顺序表的基本操作
顺序表是一种线性表的存储结构，使用一组连续的存储单元来存储元素，其基本操作包括：
1. 初始化：创建一个空顺序表，设置其长度为0。

2. 插入元素：在顺序表的指定位置插入一个元素，需要将插入位置之后的元素依次向后移动，然后将新元素放入插入位置，并更新顺序表的长度。

3. 删除元素：删除顺序表中的指定位置的元素，需要将删除位置之后的元素依次向前移动，然后更新顺序表的长度。

4. 查找元素：根据元素的值，查找顺序表中第一个与该值相等的元素，并返回其位置。

如果不存在，则返回-1。

5. 获取元素：根据位置，返回顺序表中指定位置的元素。

6. 修改元素：根据位置，修改顺序表中指定位置的元素。

7. 清空顺序表：将顺序表的长度设置为0，即清空元素。

这些基本操作可以根据具体需求进行使用和扩展。

一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作，并通过实际编程操作，加深对数据结构理论知识的理解，提高编程能力和算法设计能力。

二、实验内容1. 线性表（1）顺序表1）初始化顺序表2）向顺序表插入元素3）从顺序表删除元素4）查找顺序表中的元素5）顺序表的逆序操作（2）链表1）创建链表2）在链表中插入元素3）在链表中删除元素4）查找链表中的元素5）链表的逆序操作2. 栈与队列（1）栈1）栈的初始化2）入栈操作3）出栈操作4）获取栈顶元素5）判断栈是否为空（2）队列1）队列的初始化2）入队操作3）出队操作4）获取队首元素5）判断队列是否为空3. 树与图（1）二叉树1）创建二叉树2）遍历二叉树（前序、中序、后序）3）求二叉树的深度4）求二叉树的宽度5）二叉树的镜像（2）图1）创建图2）图的深度优先遍历3）图的广度优先遍历4）最小生成树5）最短路径三、实验过程1. 线性表（1）顺序表1）初始化顺序表：创建一个长度为10的顺序表，初始化为空。

2）向顺序表插入元素：在顺序表的第i个位置插入元素x。

3）从顺序表删除元素：从顺序表中删除第i个位置的元素。

4）查找顺序表中的元素：在顺序表中查找元素x。

5）顺序表的逆序操作：将顺序表中的元素逆序排列。

（2）链表1）创建链表：创建一个带头结点的循环链表。

2）在链表中插入元素：在链表的第i个位置插入元素x。

3）在链表中删除元素：从链表中删除第i个位置的元素。

4）查找链表中的元素：在链表中查找元素x。

5）链表的逆序操作：将链表中的元素逆序排列。

2. 栈与队列（1）栈1）栈的初始化：创建一个栈，初始化为空。

2）入栈操作：将元素x压入栈中。

3）出栈操作：从栈中弹出元素。

4）获取栈顶元素：获取栈顶元素。

5）判断栈是否为空：判断栈是否为空。

（2）队列1）队列的初始化：创建一个队列，初始化为空。

2）入队操作：将元素x入队。

3）出队操作：从队列中出队元素。

顺序表的平均比较次数
顺序表是一种基本的数据结构，其中元素按照其在内存中的物理顺序存储。

在顺序表中进行查找操作时，平均比较次数是一个重要的性能指标，它可以帮助我们评估查找算法的效率。

平均比较次数的计算涉及到查找算法的具体实现和数据分布情况。

对于顺序表的线性查找算法来说，平均比较次数取决于查找元素的概率分布以及查找元素的位置。

假设顺序表中有n个元素，每个元素被查找的概率相等，那么平均比较次数可以近似地表示为
n/2。

这是因为在最坏情况下，需要比较n次才能找到目标元素；在最好情况下，只需要比较1次。

因此，平均比较次数约为n/2。

然而，在实际情况下，元素的查找概率往往是不均匀的，有些元素可能被查找的概率更高，而有些元素可能更少。

这种情况下，可以利用加权平均比较次数来更准确地评估查找算法的性能。

加权平均比较次数的计算需要考虑每个元素被查找的概率，以及在查找过程中的比较次数。

除了理论分析外，还可以通过实验来估计顺序表的平均比较次数。

通过对不同规模的数据集进行查找操作，并统计比较次数的平
均值，可以得到实际的平均比较次数。

这种方法可以更贴近实际应用场景，帮助我们评估查找算法的实际性能。

总之，顺序表的平均比较次数是一个重要的性能指标，它可以帮助我们评估查找算法的效率。

在计算平均比较次数时，需要考虑查找元素的概率分布、元素位置以及实际应用场景，可以通过理论分析和实验方法来进行评估。

【数据结构】线性表顺序表详解和代码实例线性表(List)是零个或者多个数据元素的有限序列.⾸先它是⼀个序列.⾥⾯的元素是有顺序的,如果有多个元素,除开头和结尾以外的元素都有⼀个前驱和⼀个后继.⽽开头元素只有后继,结尾元素只有前驱.其次线性表是有限的，也就是⾥⾯的元素个数是有限的。

1ADT 线性表（List）2Data3线性表的数据对象集合为{a1, a2, a3, ......, an},每个元素类型为DataType。

4Operation5InitList(L); //初始化线性表6 IsEmptyList(L); //判断线性表是否为空7 ClearList(L); //清空线性表8 GetElemList(L, i, *e); //获取第i个位置的数据9 SearchList(L, e); //查找与数据e相等的元素10 InsertNodeList(L, i, e);//在第i个位置插⼊元素11 DeleteNodeList(L, i, *e);//删除第i个位置的元素，e获取删除元素12 GetLengthList(L); //获取线性表的长度13endADT关于线性表的基本操作就上⾯⼏种，还有⼏个例如线性表的排序，合并，逆序等等操作。

为了⽂章篇幅，就下次再介绍了。

线性表的顺序存储结构，就是指 ⽤⼀段地址连续的存储单元⼀次存储线性表的数据元素。

学过⾼级语⾔的朋友，相信对数组这玩意⼉都不会陌⽣吧。

数组就是⼀种顺序存储结构。

链式存储结构就是可以⽤⼀组任意的内存单元存储线性表中的元素。

与顺序存储不同的是，这组内存单元可以是连续的，也可以是不连续的。

这就意味着，元素可以存储在内存的任意位置。

正因为如此，在链式结构中，每个元素不仅要存它的信息，还需要存储它后继元素的存储地址。

我们把存储元素信息的域称为数据域，⽽把存储后继元素地址的域称为指针域。

由这两部分共同组成的数据元素ai，则可以称之为节点(Node)。

C#数据结构之顺序表（SeqList）实例详解本⽂实例讲述了C#数据结构之顺序表(SeqList)实现⽅法。

分享给⼤家供⼤家参考，具体如下：线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征⽤图形表⽰如下：即：每个元素前⾯有且只有⼀个元素(称为“前驱”)，同样后⾯有且只有⼀个元素(称为"后继")--注：起始元素的前驱认为是空，末尾元素的后继认为也是空，这样在概念上就不冲突了。

线性表(List)是线性结构的⼀种典型实现，它⼜可以分为：顺序表(SeqList)和链表(LinkList)⼆⼤类.顺序表（SeqList）的基本特征为：元素在内部存储时是⼀个接⼀个在存储单元中按顺序存储的，所以只要知道"起始元素的存储地址"--称为顺序表的基地址(Base Address)以及顺序表中任何元素的位置(即它是第⼏个元素)，就能直接定位到该元素的地址，从⽽直接访问到该元素的值。

也就是说存储/读取每个元素所⽤的时间是相同的，即所谓的“随机存取”C#语⾔中数组(Array)在内存中占⽤的就是⼀组连续的存储区域，所以⽤数组来实现顺序表再适⽤不过。

先来定义线性表的通⽤接⼝IListDS.cs(注：DS为DataStructure的缩写)namespace 线性表{public interface IListDS<T>{//取得线性表的实际元素个数int Count();//清空线性表void Clear();//判断线性表是否为空bool IsEmpty();//（在末端）追加元素void Append(T item);//在位置i“前⾯”插⼊元素itemvoid InsertBefore(T item, int i);//在位置i“后⾯”插⼊元素itemvoid InsertAfter(T item, int i);//删除索引i处的元素T RemoveAt(int i);//获得索引位置i处的元素T GetItemAt(int i);//返回元素value的索引int IndexOf(T value);//反转线性表的所有元素void Reverse();}}顺序表(SeqList)的实现：using System;using System.Text;namespace 线性表{/// <summary>/// 顺序表/// </summary>/// <typeparam name="T"></typeparam>public class SeqList<T> : IListDS<T>{private int maxsize;private T[] data;private int last;//类索引器public T this[int index]{get{return this.GetItemAt(index);}set{if (index < 0 || index > last + 1)Console.WriteLine("Position is error");return;}data[index] = value;}}//最后⼀个元素的下标public int Last{get { return last; }}//最⼤容量public int Maxsize{get { return this.maxsize; }set { this.maxsize = value; }}//构造函数public SeqList(int size){data = new T[size];maxsize = size;last = -1;}//返回链表的实际长度public int Count(){return last + 1;}//清空public void Clear(){last = -1;}//是否空public bool IsEmpty(){return last == -1;}//是否满public bool IsFull(){return last == maxsize - 1;}//(在最后位置)追加元素public void Append(T item){if (IsFull()){Console.WriteLine("List is full");return;}data[++last] = item;}/// <summary>///前插/// </summary>/// <param name="item">要插⼊的元素</param> /// <param name="i">要插⼊的位置索引</param> public void InsertBefore(T item, int i){if (IsFull()){Console.WriteLine("List is full");return;}if (i < 0 || i > last + 1){Console.WriteLine("Position is error");return;}if (i == last + 1){data[last + 1] = item;}{//位置i及i以后的元素，全部后移for (int j = last; j >= i; j--){data[j + 1] = data[j];}data[i] = item;}++last;}/// <summary>/// 后插/// </summary>/// <param name="item"></param>/// <param name="i"></param>public void InsertAfter(T item, int i){if (IsFull()){Console.WriteLine("List is full");return;}if (i < 0 || i > last){Console.WriteLine("Position is error");return;}if (i == last){data[last + 1] = item;}else{//位置i以后的元素(不含位置i)，全部后移for (int j = last; j > i; j--){data[j + 1] = data[j];}data[i+1] = item;}++last;}/// <summary>/// 删除元素/// </summary>/// <param name="i">要删除的元素索引</param> /// <returns></returns>public T RemoveAt(int i){T tmp = default(T);if (IsEmpty()){Console.WriteLine("List is empty");return tmp;}if (i < 0 || i > last){Console.WriteLine("Position is error!");return tmp;}if (i == last){tmp = data[last];}else{tmp = data[i];//位置i以及i以后的元素前移for (int j = i; j <= last; j++){data[j] = data[j + 1];}}--last;return tmp;}/// <summary>/// 获取第⼏个位置的元素/// </summary>/// <param name="i">第⼏个位置</param>/// <returns></returns>public T GetItemAt(int i){if (IsEmpty() || (i < 0) || (i > last)){Console.WriteLine("List is empty or Position is error!"); return default(T);}return data[i];}/// <summary>/// 定位元素的下标索引/// </summary>/// <param name="value"></param>/// <returns></returns>public int IndexOf(T value){if (IsEmpty()){Console.WriteLine("List is Empty!");return -1;}int i = 0;for (i = 0; i <= last; i++){if (value.Equals(data[i])){break;}}if (i > last){return -1;}return i;}/// <summary>/// 元素反转/// </summary>public void Reverse(){T tmp = default(T);for (int i = 0; i <= last / 2; i++){tmp = data[i];data[i] = data[last-i];data[last-i] = tmp;}}public override string ToString(){StringBuilder sb = new StringBuilder();for (int i = 0; i <= last; i++){sb.Append(data[i].ToString() + "，");}return sb.ToString().TrimEnd('，');}}}测试代码⽚段：Console.WriteLine("顺序表测试开始...");SeqList<string> seq = new SeqList<string>(10);seq.Append("x");seq.InsertBefore("w", 0);seq.InsertBefore("v", 0);seq.Append("y");seq.InsertBefore("z", seq.Count());Console.WriteLine(seq.Count());//5Console.WriteLine(seq.ToString());//v,w,x,y,zConsole.WriteLine(seq[1]);//wConsole.WriteLine(seq[0]);//vConsole.WriteLine(seq[4]);//zConsole.WriteLine(seq.IndexOf("z"));//4Console.WriteLine(seq.RemoveAt(2));//xConsole.WriteLine(seq.ToString());//v,w,y,zseq.InsertBefore("x", 2);Console.WriteLine(seq.ToString());//v,w,x,y,zConsole.WriteLine(seq.GetItemAt(2));//xseq.Reverse();Console.WriteLine(seq.ToString());//z,y,x,w,vseq.InsertAfter("z_1", 0);seq.InsertAfter("y_1", 2);seq.InsertAfter("v_1", seq.Count()-1);Console.WriteLine(seq.ToString());//z，z_1，y，y_1，x，w，v，v_1顺序表的优点：读取元素时可直接定位，所以在某些操作(⽐如将顺序表元素反转合围)中，不需要完全遍历，循环次数(即时间复杂度)相对完全遍历⽽⾔能减少⼀半。

数据结构实验报告顺序表(此⽂档为word格式，下载后您可任意编辑修改！)江西理⼯⼤学软件学院计算机类课程实验报告课程名称：数据结构班级：姓名：学号：江西理⼯⼤学软件学院实验⼆：顺序表2012年11⽉10⽇⼀. 实验⽬的掌握顺序表的逻辑结构、存储结构、以及操作。

⼆. 问题描述线性表是由n(n≥0)个元素（结点）a1, a2, …, a n组成的有限序列，其中a i中的i称为该数据元素的位置（序号），n为数据元素的个数（表的长度），当n等于0时称为空表。

按逻辑次序依次把数据元素存放在⼀组连续的地址存储单元⾥的线性表称为顺序表。

在这⾥，我们通过C++中的动态数组来实现顺序表的存放，并通过建⽴顺序表类实现它的各种操作。

三. 实验要求实现顺序表的三个框架操作：随机⽣成，⽤已有顺序表初始化另⼀个顺序表，输⼊顺序表。

以及⼗个基本操作：在第i个元素之前插⼊元素，判断是否为空，求元素个数，取第i个元素，查找第⼀个与e满⾜compare()关系的元素，返回元素的前驱，返回后继，删除第i个元素，把⼀个顺序表赋值给另⼀个顺序表，置空顺序表。

四. 实验环境3323机房OS：WxpC环境：1、TC2.02、VC++ 6.0 五．运⾏结果程序开始界⾯1.随机⽣成顺序表（元素值为0到99之间的整数）2. ⽤已有的顺序表初始化另⼀个顺序表3. 输⼊顺序表基本操作：1.在第i个元素之前插⼊⼀个元素2. 判断顺序表是否为空3. 求顺序表中元素的个数4. 取第i个元素5. 查找第⼀个与之满⾜compare()关系的元素序号6. 返回某元素的前驱7. 返回某元素的后继8. 删除第i个元素9. 把⼀个顺序表复制给另⼀个顺序表10. 把顺序表置空11.顺序表的运⽤六．实验⼼得熟悉最基本的数据类型——顺序表，同时我们让我们熟练C++的基本操作，模板的使⽤，以及模块化的设计思想。

同时也运⽤顺序表做⼀些简单的运⽤，⽐如顺序表的并交差运算，学⽣管理系统等等。

数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能：（1）初始化顺序表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。

2、编写程序实现单链表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。

1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满，增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。

顺序表的建⽴、输⼊、输出、查找、插⼊、删除（数据结构）1.顺序表的基本操作实践。

(1)建⽴4个元素的顺序表list[]={2，3，4，5}，实现顺序表建⽴的基本操作。

(2)在list[]={2，3，4，5}的元素4和5之间插⼊⼀个元素9，实现顺序表插⼊的基本操作。

(3)在list[]={2，3，4，9，5}中删除指定位置（i=3）上的元素4，实现顺序表的删除的基本操作。

#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列，建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0。

4.判断该顺序表中元素是否对称，对称返回1，否则返回0。

5.实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数，调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素：",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕！...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数，后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一：顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0");printf("\n 4.判断该顺序表中元素是否对称，对称返回1，否则返回0");printf("\n 5.该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号：");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值：X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1）程序主界面2）选择1建立顺序表3）选择2遍历顺序表4）选择3查询元素X5）选择4判断是否对称6）选择5奇数在前，偶数在后7）选择0退出。