顺序表查找算法的实现

合集下载

数据结构能力测试集训题目

数据结构能力测试集训题目

数据结构能力测试集训题目线性表1.实现顺序表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化顺序表L;(2)采用尾插法依次插入a,b,c,d,e;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出顺序表L;(10)删除顺序表L的第3个元素;(11)输出顺序表L;(12)释放顺序表L。

2.实现单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化单链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出单链表h;(4)输出单链表h的长度;(5)判断单链表h是否为空;(6)输出单链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出单链表h;(10)删除单链表h的第3个元素;(11)输出单链表h;(12)释放单链表h;3.实现双链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化双链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出双链表h;(4)输出双链表h的长度;(5)判断双链表h是否为空;(6)输出双链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出双链表h;(10)删除双链表h的第3个元素;(11)输出双链表h;(12)释放双链表h;4.实现循环单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化循环单链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出循环单链表h;(4)输出循环单链表h的长度;(5)判断循环单链表h是否为空;(6)输出循环单链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出循环单链表h;(10)删除循环单链表h的第3个元素;(11)输出循环单链表h;(12)释放循环单链表h;5.实现循环单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化循环双链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出循环双链表h;(4)输出循环双链表h的长度;(5)判断循环双链表h是否为空;(6)输出循环双链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出循环双链表h;(10)删除循环双链表h的第3个元素;(11)输出循环双链表h;(12)释放循环双链表h;6.求集合的并,交,差运算(用有序单链表表示)栈和队列7.实现顺序栈各种基本运算的算法,编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序完成以下各种功能:(1)初始化栈s(2)判断栈s是否非空(3)依次进栈元素a,b,c,d,e(4)判断栈s是否非空(5)输出栈长度(6)输出从栈顶到栈底元素(7)输出出栈序列(8)判断栈s是否非空(9)释放栈8.实现链栈各种基本运算的算法,编写一个程序,实现链栈的各种基本算法,并在此基础上设计一个主程序完成如下功能:(1)初始化链栈s(2)判断链栈s是否非空(3)依次进栈元素a,b,c,d,e(4)判断链栈s是否非空(5)输出链栈长度(6)输出从栈顶到栈底元素(7)输出链栈序列(8)判断链栈s是否非空(9)释放链栈9.实现顺序队列各种基本运算的算法,编写一个程序,实现顺序循环队列各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化队列q(2)判断队列q是否非空(3)依次进队列元素a,b,c(4)出队一个元素,输出该元素(5)输出队列q的元素的个数(6)依次进队列元素d,e,f(7)输出队列q的元素的个数(8)输出出队序列(9)释放队列10.实现链队各种基本运算的算法,编写一个程序,实现链队的各种基本运算,在此基础上设计一个主程序完成如下功能:(1)初始化链队q(2)判断链队q是否非空(3)依次进链队元素a,b,c(4)出队一个元素,输出该元素(5)输出链队q的元素的个数(6)依次进链队元素d,e,f(7)输出链队q的元素的个数(8)输出出队序列(9)释放链队串11.实现顺序串各种基本运算的算法,编写一个程序实现顺序的基本运算的算法,比在此基础上设计一个主程序完成如下功能:(1)建立s=”abcdefghefghijklmn”和串s1=”xyz”(2)输出串s(3)输出串s的长度(4)在串s的第9个字符位置插入串s1而产生串s2(5)输出串s2(6)删除串s第2个字符开始的5个字符而产生的串s2(7)输出串s2(8)将串s第2个字符开始的5个字符替换成串s1而产生串s2(9)输出串s2(10)提取串s的第2个字符开始的10个字符而产生串s3(11)输出串s3(12)将串s1和串s2连接起来而产生的串s4(13)输出串s412.实现链串个各种基本运算的算法,编写一个程序实现链串的各种基本运算,并在此基础上设计一个主程序完成如下功能;(1)建立s=”abcdefghefghijklmn”和串s1=”xyz”(2)输出串s(3)输出串s的长度(4)在串s的第9个字符位置插入串s1而产生串s2(5)输出串s2(6)删除串s第2个字符开始的5个字符而产生的串s2(7)输出串s2(8)将串s第2个字符开始的5个字符替换成串s1而产生串s2(9)输出串s2(10)提取串s的第2个字符开始的10个字符而产生串s3(11)输出串s3(12)将串s1和串s2连接起来而产生的串s4(13)输出串s413.顺序串的各种模式匹配运算,编写一个程序实现顺序串的各种模式匹配运算,并在此基础上完成如下功能:(1)建立”abcabcdabcdeabcdefabcdefg”目标串s和”abcdeabcdefab”模式串t(2)采用简单匹配算法求t在s中的位置(3)由模式串t求出next值和nextval值(4)采用KMP算法求t在s中的位置(5)采用改进的KMP算法求t在s中的位置查找14.实现顺序查找的算法,编写一个程序输出在顺序表{3,6,2,10,1,8,5,7,4,9}中采用顺序方法查找关键字5的过程。

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

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

实现顺序表的各种基本运算的算法顺序表是一种基本的数据结构,它可以存储线性结构,支持随机访问,具有较好的存储效率。

在实际应用中,我们需要实现顺序表的各种基本运算,包括插入、删除、查找、遍历、排序等操作。

下面介绍一些实现顺序表基本运算的算法。

1.插入算法顺序表插入算法的基本思路是:将插入位置之后的所有元素向后移动一位,然后将待插入元素放入插入位置。

具体实现如下:```void Insert(SqList &L, int pos, int data){if (pos < 1 || pos > L.length + 1) // 插入位置非法return;if (L.length == L.MAXSIZE) // 顺序表已满return;for (int i = L.length; i >= pos; i--) // 将pos以后的元素依次后移,腾出pos位置L.data[i] = L.data[i - 1];L.data[pos - 1] = data; // 将新元素插入pos位置L.length++; // 顺序表长度+1}```2.删除算法顺序表删除算法的基本思路是:将待删除元素之后的所有元素向前移动一位,然后将顺序表长度减1。

具体实现如下:```void Delete(SqList &L, int pos){if (pos < 1 || pos > L.length) // 删除位置非法return;for (int i = pos; i < L.length; i++) // 将pos以后的元素依次前移,覆盖pos位置L.data[i - 1] = L.data[i];L.length--; // 顺序表长度-1}```3.查找算法顺序表查找算法的基本思路是:从表头开始逐个比较元素,直到找到目标元素或者搜索到表尾。

具体实现如下:```int Search(SqList L, int data){for (int i = 0; i < L.length; i++){if (L.data[i] == data) // 找到目标元素,返回其下标return i;}return -1; // 未找到目标元素,返回-1}```4.遍历算法顺序表遍历算法的基本思路是:从表头开始依次输出元素。

数据结构与算法实验报告5-查找与排序

数据结构与算法实验报告5-查找与排序

北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。

在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。

顺序查找的思路

顺序查找的思路

顺序查找的思路顺序查找是指从一个有序表或者无序表中,一个个地去查找给定的关键字,把符合条件的关键字找出来的一种方法。

它是最简单也是最基本的一种查找算法,是一种只要能够比较和排序的查找算法。

顺序查找的思路就是:从表的第一个元素开始,依次与给定的关键字比较,若比较成功,则表示找到了要查找的关键字;若比较失败,则比较下一个元素;如此反复,直到把表中所有元素都比较一遍为止,这样就完成了顺序查找。

顺序查找的优缺点优点:1、顺序查找是基于比较的查找方法,能够支持任意的数据类型,并且不依赖于数据的存储结构;2、实现起来比较简单,查找的效率也比较高;3、它能够用在无序和有序的表中。

缺点:1、查找效率是随着表的长度而增加的,当表的长度增加,查找的时间就会越长;2、对于大规模的表来说,它效率低,比较次数较多,查找速度也较慢;3、顺序表需要较多的存储空间。

顺序查找的实现1、首先要明确要查询的关键字,然后从顺序表的第一个元素开始;2、比较每一个元素与关键字是否相同,若相同则找到了要查找的关键字;3、若不相同,则将当前元素放到下一个元素进行比较,如此循环比较;4、如果顺序表的元素都比较完,却没有找到要查找的关键字,则表示查找失败,结束查找。

顺序查找的应用1、在编程语言中,我们经常用顺序查找来查找字符串;2、在数据库系统中,也会使用顺序查找来查找特定的数据;3、在文件搜索器中,也可以使用顺序查找来搜索文件;4、在编译器中,编译器会使用顺序查找来查找关键字;5、在网络资源中,也可以使用顺序查找来搜索想要的资源。

总结顺序查找是指一次比较一个元素,然后依次比较下一个元素,直到顺序表的所有元素都比较完为止,也就是要比较整张表。

它是一种简单易实现的查找算法,能够适用于无序和有序的表中,但是由于其时间复杂度较高,在大规模的表中查找效率不高,因此开发人员不会选择它。

因此,在开发实际应用程序时,应该根据实际的情况,根据需要使用不同的查找算法,以便更好地提升查找的效率。

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

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

实现顺序表的各种基本运算的算法
1.初始化顺序表:首先需要定义一个数组来存储顺序表中的元素,在初始化顺序表时,需要给定顺序表的大小,即可创建一个空的顺序表。

2. 插入元素:要在顺序表中插入一个元素,需要确定插入位置
和插入元素的值。

插入元素时,需要将插入位置后面的元素都向后移动一位,然后将插入元素插入到插入位置。

3. 删除元素:要从顺序表中删除一个元素,需要确定删除位置。

删除元素时,需要将删除位置后面的元素都向前移动一位,然后将最后一个元素移到删除位置处,即可完成删除操作。

4. 查找元素:要在顺序表中查找一个元素,可以使用顺序查找
或者二分查找算法。

顺序查找需要遍历整个顺序表,而二分查找需要先对顺序表进行排序,然后再进行查找。

5. 修改元素:要修改顺序表中的一个元素,需要先查找到该元
素的位置,然后再进行修改操作。

6. 获取顺序表长度:顺序表的长度就是顺序表中元素的个数,
可以通过遍历整个顺序表来获取其长度。

7. 清空顺序表:清空顺序表就是将顺序表中的元素全部删除,
可以通过遍历整个顺序表进行删除操作来实现。

8. 销毁顺序表:销毁顺序表就是释放顺序表所占用的内存空间,可以通过调用系统函数来实现。

以上就是实现顺序表的各种基本运算的算法。

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

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

实现顺序表各种基本运算的算法.doc
创建顺序表:创建顺序表需要先确定表的大小,即容量。

可以通过动态分配内存来创建顺序表,或者直接在程序中定义一个静态数组作为顺序表的存储空间。

创建时需要初始化表中元素的数量为0。

插入元素:在顺序表中插入元素时,需要先判断表是否已满。

如果表已满,则需要扩容。

扩容可以通过动态分配更大的内存空间,并将原有元素拷贝到新的内存空间中来实现。

如果表未满,则可以直接在表的末尾插入元素。

如果要在指定位置插入元素,则需要先将该位置及其后面的元素依次后移一个位置,再在该位置插入新元素。

删除元素:在顺序表中删除元素时,需要先判断要删除的元素是否存在。

如果不存在,则无需进行任何操作。

如果存在,则可以直接删除该元素。

如果要删除指定位置的元素,则需要先将该位置后面的元素依次前移一个位置,再将表中元素的数量减1。

查找元素:在顺序表中查找元素时,可以使用顺序查找或二分查找算法。

顺序查找的时间复杂度为O(n),而二分查找的时间复杂度为O(log n)。

在使用二分查找时,需要保证顺序表中的元素已经按照升序或降序排列。

修改元素:在顺序表中修改元素时,需要先查找该元素的位置,然后将其修改为新值。

输出顺序表:输出顺序表时,需要遍历表中所有元素,并将它们依次输出。

可以使用循环来实现遍历。

总之,实现顺序表的基本运算需要涉及到动态内存分配、数组操作、循环遍历和查找算法等知识点。

在实际应用中,还需要考虑如何优化算法效率、如何处理异常情况等问题。

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

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

实现顺序表的各种基本运算的算法1. 初始化顺序表算法实现:初始化操作就是将顺序表中所有元素的值设置为默认值,对于数值类型,可以将其设置为0,对于字符类型,可以将其设置为空格字符。

初始化的时间复杂度为O(n),其中n为顺序表的长度。

2. 插入操作算法实现:顺序表的插入操作就是在指定位置上插入一个元素,需要将该位置后面的元素全部后移,在指定位置上插入新元素。

若顺序表已满,则需要进行扩容操作,将顺序表长度扩大一倍或者按一定的比例扩大。

插入操作的时间复杂度为O(n),其中n为顺序表长度。

3. 删除操作算法实现:顺序表的删除操作需要将指定位置上的元素删除,并将该位置后面的元素全部前移。

删除操作后,如果顺序表的实际长度小于等于其总长度的1/4,则需要进行缩容操作,将顺序表长度缩小一倍或者按一定的比例缩小。

删除操作的时间复杂度为O(n),其中n为顺序表长度。

4. 修改操作算法实现:顺序表的修改操作就是将指定位置上的元素赋予新的值。

修改操作的时间复杂度为O(1)。

5. 查找操作算法实现:顺序表的查找操作就是在顺序表中找到指定位置的元素,并返回其值。

查找操作的时间复杂度为O(1)。

6. 遍历操作算法实现:顺序表的遍历操作就是依次访问顺序表中的每个元素,遍历操作的时间复杂度为O(n),其中n为顺序表的长度。

7. 合并操作算法实现:顺序表的合并操作就是将两个顺序表合并成一个新的顺序表,新的顺序表的长度为两个顺序表的长度之和。

合并操作的时间复杂度为O(n),其中n为两个顺序表的长度之和。

总结:顺序表是一种简单而高效的数据结构,其基本运算包括初始化、插入、删除、修改、查找、遍历和合并等操作。

其中,插入、删除、遍历和合并操作的时间复杂度比较高,需要进行相应的优化处理。

同时,在实际应用中,还需要注意顺序表的扩容和缩容操作,避免造成资源浪费或者性能下降。

数据结构-7顺序查找与二分查找

数据结构-7顺序查找与二分查找

i=m+1=8,j=8, m=(i+j)/2=8。 r[m]>k : 在左半部分继续查找。
i=8, j=m-1=7 ,
i>j: 查找失败
存储结构
key info 0 1 k1 2 k2 3 k3
…………
n kn
typedef struct { keytype key; ………….
} elemtype;
分块有序表的结构可以分为两部分: 1、线性表本身是顺序存储结构 2、再建立一个索引表,线性表中每个子表建立一个索引节点
。索引节点包括两部分:一是数据域,一是指针域。数据域存 放对应子表中的最大元素值,指针域用于指示子表第一个元素 的在整个表中序号。
分块查找
template<class T> struct indnode {
key=32
d (1) 27
i=1
d (2) 36
i=2
d (3) 32i=3 Nhomakorabead (4) 18
此时d(i)=key,数组中的第3个位置
如果输入查找的元素值key=22
d (1) 27 i=1
d (2) 36 i=2
d (3) 32 i=3
d (4) 18
i=4 i=5 此时i等于5,超过数组中元素个数,找不到
T key; int k; };
上图查找过程:首先查找索引表,确定查找的子表,然后再相应的子表中 应顺序表查找法查找。
• int blksearch(record r[],index idx[],keytype key)
•{
• int i=0,j;
• while(i<idxN)
•{
• if(key<=idx[i].key){

顺序表的建立与基本算法

顺序表的建立与基本算法

顺序表的建立与基本算法
顺序表是数据结构中最基本、最常见的存储结构。

它是一组在一起的有组织地存储在内存中的相关数据项,以便快速访问和修改。

顺序表的建立与基本算法主要包括以下几点:
一、建立顺序表
1.定义存储空间大小:首先要确定存储空间大小,根据实际情况来确定。

2.申请内存空间:将需要的内存空间分配给顺序表,用于存放后面的数据元素。

3.初始化顺序表:将顺序表的长度初始化为0,表示此时顺序表是空表,然后给顺序表的数据元素赋初值,例如-1、0、NULL等。

4.插入数据元素:在指定位置插入数据元素到顺序表上。

5.释放内存空间:当顺序表使用完毕,需要释放顺序表所申请的内存空间,回收内存。

二、顺序表的基本算法
1.查找算法:在顺序表中查找特定的数据元素,通过遍历顺序表的方式来查找,可以通过比较元素的特征值来区分,查找的时间复杂度为O(n)。

2.插入算法:在顺序表中插入数据元素,需要先判断顺序表是否已满,如果未满则在指定位置插入数据元素,需要将插入位置后面的元素都后移一个位置,插入的时间复杂度为O(n)。

3.删除算法:在顺序表中删除数据元素,需要先判断顺序表是否为空,如果非空则在指定位置删除数据元素,需要将删除位置后面的元素都前移一个位置,删除的时间复杂度为O(n)。

4.更新算法:更新顺序表中的数据元素,需要先查找到特定的元素,然后根据需要更新数据元素,更新的时间复杂度也是O(n)。

总的来说,顺序表的建立与基本算法包括建立顺序表,查找算法,插入算法,删除算法,更新算法等几个方面,都要结合实际情况具体
操作,时间复杂度都是O(n)。

顺序表的查找-顺序查找

顺序表的查找-顺序查找

顺序表的查找-顺序查找查找(search):给定结点的关键字值 x ,查找值等于 x 的结点的存储地址。

按关键字 x 查:①成功,表中有 x ,返回 x 的存储地址;②不成功,x 不在表中,返回⽆效地址。

顺序查找就是以表的⼀端为起点,向另⼀个端点逐个元素查看,可以是从表头→表尾的顺序,也可以是从表尾→表头的顺序顺序查找⽅法,既适⽤于⽆序表,⼜适⽤于有序表。

顺序查找属于 “穷尽式搜索法”:通常以查找长度,度量查找算法的时间复杂性。

查找长度:即查找过程中测试的节点数⽬。

顺序查找的查找长度 = for 循环体的执⾏次数,最⼩为1,最多为n。

等概率下:平均查找长度 = (n + 1)/ 2最坏情况和平均情况:T(n)= O(n)效率最低的查找算法我们观察⼀下上图那两个 for循环体,不难发现,每次执⾏都需要判断两个条件:①测试是否循环到头;②测试是否找到元素 x。

因此我们不妨使⽤ “监督元” 技术,不仅简化了程序结构,也提⾼了查找速度。

若从表尾→表头的顺序查找,监督元则在表头处,称为 “表头监督元”,如下图:若从表头→表尾的顺序查找,监督元则在表头处,称为 “表尾监督元”,如下图:带表头监督元的顺序查找算法:int SQsearch(int a[],int x,int n){ // SQsearch 是函数名,仅此。

int i; i = n; a[0] = x; while(a[i] != x) i -- ; return i;}算法思想:① i = n;// 设置查找起点② a[0] = x;// 放置监督元,因为在进⼊循环体之前,已经预先在 a[0] 放置了⼀个元素 x,所以 x ⽆论是否真的在表中,总能找到 x ,使第三句的循环中⽌。

注意a[1] 到 a[n] 存储的才是真正的表元素。

如果 x 真存在表中,必然在某个 i ⼤于 0 时找到 x,循环终⽌。

如果循环变量 i 的值变到 0 时循环才终⽌,那就说明 x 不在表中。

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。

2.从键盘输入1个整数,在顺序表搜寻该结点的边线。

若找出,输入结点的边线;若打听不到,则显示“找不到”。

3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。

4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。

二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。

数据结构上机实验指导

数据结构上机实验指导

《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。

设计和验证顺序表的查找、插入、删除算法。

【实验要求】(1)从键盘读入一组整数,按输入顺序形成顺序表。

并将创建好的顺序表元素依次打印在屏幕上。

(2)设计一个带选择菜单的主函数,菜单中具备任意选择删除、插入、查找数据元素的功能。

(3)当选择删除功能时,从键盘读入欲删除的元素位置或元素值,按指定方式删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号。

(4)每种操作结束后,都能在屏幕上打印出此时顺序表元素的遍历结果。

【实验步骤】1、实验前先写好算法。

2、上机编写程序。

3、编译。

4、调试。

例程:书上参考算法2-1,2-4,2-5,2-6,2-8!带菜单的主函数参考书上2.5综合实例!注意:顺序表的结构体!typedef struct{datatype items[listsize];int length;}SpList;实验二【实验名称】单链表的基本算法【实验目的】创建一个单链表,掌握线性表链式存储的特点。

设计和验证链表的查找、插入、删除、求表长的算法。

【实验要求】(1)从键盘读入一组整数,按输入顺序形成单链表。

并将创建好的单链表元素依次打印在屏幕上。

(注意:选择头插法或者尾插法!)(2)设计一个带选择功能菜单的主函数,菜单中至少具备任意选择删除、插入、查找数据元素,和求单链表表长等几项功能。

(3)当选择删除功能时,从键盘读入欲删除的元素位置,按指定位置删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号;当选择求表长功能时,返回该单链表表长的数值。

(4)每种操作结束后,都能在屏幕上打印出此时单链表元素的遍历结果。

【实验步骤】1、实验前先写好算法。

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

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

实现顺序表的各种基本运算的算法顺序表是一种线性表,可以用数组来实现。

在顺序表中,数据元素在数组中的存储位置是按照逻辑顺序依次排列的。

顺序表中的基本运算包括插入、删除、查找、遍历等。

1. 插入操作顺序表的插入操作是指在顺序表中的指定位置插入一个元素。

插入操作分为两种情况:(1) 在顺序表的末尾插入元素;(2) 在顺序表的中间插入元素。

插入操作算法如下:(1) 在顺序表的末尾插入元素:a. 判断顺序表是否已满,如果已满则输出错误信息;b. 否则将元素插入到顺序表的末尾。

(2) 在顺序表的中间插入元素:a. 判断顺序表是否已满,如果已满则输出错误信息;b. 否则将指定位置之后的元素向后移动一个位置;c. 将新元素插入到指定位置。

2. 删除操作顺序表的删除操作是指删除顺序表中指定位置的元素。

删除操作分为两种情况:(1) 删除顺序表的末尾元素;(2) 删除顺序表的中间元素。

删除操作算法如下:(1) 删除顺序表的末尾元素:a. 判断顺序表是否为空,如果为空则输出错误信息;b. 否则删除顺序表的最后一个元素。

(2) 删除顺序表的中间元素:a. 判断顺序表是否为空,如果为空则输出错误信息;b. 否则将指定位置之后的元素向前移动一个位置;c. 删除指定位置的元素。

3. 查找操作顺序表的查找操作是指在顺序表中查找指定元素的位置。

查找操作分为两种情况:(1) 查找顺序表中第一个符合条件的元素;(2) 查找顺序表中所有符合条件的元素。

查找操作算法如下:(1) 查找顺序表中第一个符合条件的元素:a. 从表头开始遍历顺序表;b. 如果找到符合条件的元素,则返回该元素的位置;c. 如果遍历完整个顺序表都没有找到符合条件的元素,则返回错误信息。

(2) 查找顺序表中所有符合条件的元素:a. 从表头开始遍历顺序表;b. 如果找到符合条件的元素,则输出该元素的位置;c. 如果遍历完整个顺序表都没有找到符合条件的元素,则输出错误信息。

顺序查找的思路

顺序查找的思路

顺序查找的思路
顺序查找是指在一组已排好序的数据中从头到尾依次查找,直到找到所要查找
的数据为止,称为顺序查找。

顺序查找算法由顺序查找表来实现,即用一个一维
数组存放关键字,按数组的顺序查找数据。

顺序查找的基本思想是:从顺序表的一端开始,顺序扫描,依次将扫描到的数据
关键字与给定值k作比较,若相等,则查找成功;若扫描结束仍没有找到关键字等于K的数据元素,表示查找失败。

由于顺序表中的数据元素是按关键字的大小次序排列的,因此它们之间存在着前后顺序关系,可以在查找过程中根据比较结果调整查找策略,使查找过程更有效率,
比如,如果给定值k小于表中的关键字,则应该继续往前查找;反之,则应该继续往后
查找,下面介绍基于顺序表实现的顺序查找算法。

假设要查找顺序表ST中值为key的元素:
(1) 从顺序表的一端开始,依次将每个数据元素与key值进行比较;
(2) 若相等,则查找成功;
(3) 否则,该数据元素不是我们要查找的目标值,就继续比较下一数据元素。

(4) 如果经过N(N为顺序表ST的长度)次比较仍没有找到关键字等于key的数据
元素,则表明不存在,查找失败。

顺序查找的查找效率不高,在大量数据量和种类庞大的情况下,其时间复杂度较高,因此顺序查找不适合于大量数据量或种类繁多的情况。

顺序表的定位算法

顺序表的定位算法

顺序表的定位算法
顺序表是一种用数组来实现的数据结构,所有元素的存储位置是连续的,因此可以很方便地通过下标来访问指定位置的元素。

顺序表的定位算法即是根据元素的值或者下标来确定元素在顺序表中
的位置。

常用的顺序表的定位算法有以下几种:
1.按元素值查找:从顺序表的第一个元素开始逐个比较,直到找到和
目标元素值相等的元素,或者遍历完整个顺序表都未找到目标元素。

2.按元素下标查找:如果已知元素的下标,可以直接用下标访问该元素。

3.二分查找:当元素值有序时,可以采用二分查找算法,先比较中间
元素的值是否等于目标元素,如果小于目标元素,则在右半部分继续查找;如果大于目标元素,则在左半部分继续查找。

重复这个过程直到找到目标
元素或者确定目标元素不存在。

通过这些算法,可以快速地定位顺序表中的元素,实现顺序表的各种
操作。

用C#实现顺序查找算法的动态演示

用C#实现顺序查找算法的动态演示
效 果 图
21 生成 初 始 数 据 并安 排界 面 .
输人 :有 n个元素 的数组 A f. ]和给定 的特定值 x 0n . 。 输出 :如果 x A [,则输 出 j = i 】 ;否则输 出 0 。 过程 :A 【】= ; 0 x
i A 啪 一 x f( ) rtr eu j n ;
Alo i m i g C g rt h Usn #
S N x n 。 Z U Yii HANG n i 2 La x a (. e at n f o ue n i er g W e a gC l g f d c t n Q n z o 6 5 0 1 D pr me t mp t E gn e n , i n ol eo u a o , ig h u 2 2 0 ; oC r i f e E i
广——— — … …一 一 一 广——— —、 _ ∞ I _
厂 mmm


— —
、—/—— V f 萄—/m { — —m— m — — —m/ _ — —、 — m r

— — — —
_ { 比的据 『 _ L 铰数 l j 正 在
— — — — —
SFW R EEOM N D EI 0r AE V LP E T N S N D A D G
软件 开发 与设 计
用 C #实 现顺 序 查 找 算 法 的 动 态 演 示
孙 义欣 ,张 兰霞
(. 1 潍坊教育学院计算机工程系 ,青州 2 2 0 ;2高密市张鲁中学 , 高密 2 13 ) 6 50 . 65 1
2 Zh n l d l c o lo o 。 o 2 1 3 ) . a guMideS h o fGa mi Ga mi 6 5 1

数据结构c++顺序表、单链表的基本操作,查找、排序代码

数据结构c++顺序表、单链表的基本操作,查找、排序代码

} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:

顺序表的定位算法

顺序表的定位算法

顺序表的定位算法
顺序表是一种线性表的存储结构,其元素按照一定的顺序依次存放在连续的存储单元中。

在顺序表中,我们需要根据给定的关键字来查找元素,这就需要用到顺序表的定位算法。

顺序表的定位算法主要有两种,分别是顺序查找和折半查找。

顺序查找是指从表的起始位置开始,逐个遍历表中的元素,直到找到目标元素为止。

这种方法的时间复杂度为O(n),其中n为表中元素的数量。

当表中元素数量较少时,顺序查找是一种简单有效的方法。

折半查找又称为二分查找,是一种更高效的查找方法。

在折半查找中,我们先将表按照关键字的大小进行排序,然后每次将查找区间缩小为原来的一半,直到找到目标元素为止。

这种方法的时间复杂度为O(log n),其中n为表中元素的数量。

当表中元素数量较大时,折半查找比顺序查找更加适用。

总之,顺序表的定位算法是线性表中最基本的算法之一,它可以帮助我们快速地查找表中的元素,提高程序的效率。

在实际应用中,我们需要根据具体情况选择不同的定位算法,以满足不同的需求。

- 1 -。

写一算法输出已知顺序表a中元素最大值和次最大值,并编写c语言程序

写一算法输出已知顺序表a中元素最大值和次最大值,并编写c语言程序

写一算法输出已知顺序表a中元素最大值和次最大值,并编写c语言程序下面是一个C语言程序,实现查找已知顺序表a中元素最大值和次最大值的算法:c#include<stdio.h>#define MAX_SIZE 100 // 定义顺序表的最大长度int main() {int a[MAX_SIZE], n, max, second_max;printf("请输入顺序表长度:");scanf("%d", &n);printf("请输入%d个元素:\n", n);for (int i = 0; i < n; i++) {scanf("%d", &a[i]);}max = a[0]; // 假设第一个元素为最大值second_max = a[0]; // 假设第一个元素为次最大值for (int i = 1; i < n; i++) {if (a[i] > max) {second_max = max;max = a[i];} else if (a[i] > second_max && a[i] < max) {second_max = a[i];}}printf("最大值为:%d\n", max);printf("次最大值为:%d\n", second_max);return0;}该程序首先定义了一个长度为MAX_SIZE的整型数组a,用于存储输入的顺序表元素。

然后,程序提示用户输入顺序表的长度n和n个元素,将它们存储在数组a中。

接下来,程序使用一个循环遍历数组a,查找最大值和次最大值。

在循环中,程序首先假设第一个元素为最大值和次最大值,然后遍历数组中的其他元素,更新最大值和次最大值。

如果当前元素比最大值还大,则将最大值和次最大值都更新为当前元素;如果当前元素比次最大值大且比最大值小,则将次最大值更新为当前元素。

查找实验报告

查找实验报告

查找实验报告第一篇:查找实验报告实验六查找实验目的:掌握几种查找的思想及算法问题分析:(一)顺序查找 1.查找思想从表的一端开始逐个将记录的关键字和给定K值进行比较,若某个记录的关键字和给定K值相等,查找成功;否则,若扫描完整个表,仍然没有找到相应的记录,则查找失败。

2.算法实现int Seq_Search(SST able ST,int key){int p;} ST.data[0].key=key;/* 设置监视哨兵,失败返回0 */ for(p=ST.length;ST.data[p].key!=key;p--);return(p);3.算法分析设查找每个记录成功的概率相等,即Pi=1/n;查找第i个元素成功的比较次数Ci=n-i+1 ;◆ 查找成功时的平均查找长度ASL:◆包含查找不成功时:查找失败的比较次数为n+1,若成功与不成功的概率相等,对每个记录的查找概率为Pi=1/(2n),则平均查找长度ASL:(二)折半查找前提条件:查找表中的所有记录是按关键字有序(升序或降序)。

查找过程中,先确定待查找记录在表中的范围,然后逐步缩小范围(每次将待查记录所在区间缩小一半),直到找到或找不到记录为止。

1.查找思想用Low、High和Mid表示待查找区间的下界、上界和中间位置指针,初值为Low=1,High=n。

⑴取中间位置Mid:Mid=⎣(Low+High)/2⎦;⑵比较中间位置记录的关键字与给定的K值:①相等:查找成功;②大于:待查记录在区间的前半段,修改上界指针:High=Mid-1,转⑴ ;③小于:待查记录在区间的后半段,修改下界指针:Low=Mid+1,转⑴ ;直到越界(Low>High),查找失败。

2.算法实现int Bin_Search(SST able ST , KeyType k){int low=1,high=ST.length, mid;while(low<=high){mid=(low+high)/2;if(EQ(ST.data[mid].key, k))return(mid);else if(LT(ST.dat[mid].key, k))low=mid+1;else high=mid-1;}return(0);/*查找失败*/ } 3.算法分析①查找时每经过一次比较,查找范围就缩小一半,该过程可用一棵二叉树表示:◆根结点就是第一次进行比较的中间位置的记录;◆ 排在中间位置前面的作为左子树的结点;◆ 排在中间位置后面的作为右子树的结点;对各子树来说都是相同的。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

算法与数据结构讲义实验五图的建立及遍历操作一、实验目的1.掌握图的存储结构和相关操作。

2.能够熟练用计算机来表示图和进行图处理。

二、实验环境1.硬件:每个学生需配备计算机一台。

操作系统:DOS或Windows;2.软件:DOS或Windows操作系统+Turbo C;三、实验要求 1.要求对于给定的图分别用邻接矩阵和邻接表示来存储。

2.对于存储好的图进行深度和广度优先遍历。

3.完成图的各种操作。

四、实验内容1.现在某网络公司的光纤连接结点如下图所示,请分别用邻接矩阵和邻接表将图存储到计算机中方便进行处理。

2.现在某网络公司的光纤连接结点如下图所示,请分别用邻接矩阵和邻接表将图存储到计算机中方便进行处理。

五、代码如下第一个实验#include<iostream>#include<string>using namespace std;#define MAX 20typedef int Adj[MAX][MAX];typedef struct{string vexs[MAX]; //顶点表Adj arcs; //邻接矩阵int vexnum,arcnum; //图的顶点和弧数}MGraph;int ylx_LocateVex(MGraph &G,string u);int ylx_CreateUDN(MGraph &G){int i,k,j;string v1,v2;cout<<"请输入顶点数、弧数:";cin>>G.vexnum>>G.arcnum;cout<<"输入顶点:";for(i=0;i<G.vexnum;i++){cin>>G.vexs[i]; //构造顶点数}for(i=0;i<G.vexnum;i++){ //构造邻接矩阵for(j=0;j<G.vexnum;j++){G.arcs[i][j]=0; } }for(k=0;k<G.arcnum;k++){cout<<"输入第"<<k+1<<"边依附的两个顶点:";cin>>v1>>v2;i=ylx_LocateVex(G,v1);j=ylx_LocateVex(G,v2);G.arcs[i][j]=1;G.arcs[j][i]=1; //置<v1,v2>的对称弧<v2,v1>}return 0;}int ylx_LocateVex(MGraph &G,string u){//确定u在G中序号int i;for (i=0;i<G.vexnum;i++){if (u==G.vexs[i])return i; }if (i==G.vexnum){cout<<"Error u!"<<endl;exit(1); }return 0;}void ylx_ShowG(MGraph &G){int i,j;for(i=0;i<G.vexnum;i++){cout<<G.vexs[i]<<" "; }cout<<endl;for(i=0;i<G.vexnum;i++){for(j=0;j<G.vexnum;j++){cout<<G.arcs[i][j]<<" ";}cout<<endl; } }main(){MGraph A;int a;a=ylx_CreateUDN(A);ylx_ShowG(A);}第二个实验#include<iostream># include <string.h># include <malloc.h># include <conio.h>using namespace std;int visited[30];# define MAX_VERTEX_NUM 30# define OK 1//typedef int VertexType;typedef int InfoType;typedef struct ArcNode //弧{ int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode//表头{ int data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct//图{ AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;void ylx_CreateDG(ALGraph &G){ int k,i,v1;cout<<endl<<"请输入结点个数: ";cin>>G.vexnum;cout<<"请输入弧的个数: ";cin>>G.arcnum;for(i=1;i<=G.vexnum;i++)//初使化表头 { G.vertices[i].data=i;G.vertices[i].firstarc=NULL; }for(k=1;k<=G.vexnum;k++) //输入边{ int v2;cout<<"请输入与结点"<<k<<"相邻的边数:";cin>>v2;cout<<"请输入与第"<<k<<"个结点相连的结点编号: ";cin>>v1;ArcNode *p;p=(ArcNode*)malloc(sizeof(ArcNode));if(!p) exit(-1);p->adjvex=v1;p->nextarc=NULL;G.vertices[k].firstarc=p;for(int i=1;i<v2;i++){ int m;cout<<"请输入与第"<<k<<"个结点相连的结点编号: ";cin>>m;ArcNode *q;q=(ArcNode*)malloc(sizeof(ArcNode));//动态指针if(!q) exit(-1);q->adjvex=m; //顶点给Pq->nextarc=NULL;p->nextarc=q;p=q;//free(q); }//free(p); } }void ylx_DFS (ALGraph G,int v )//深度搜索{visited[v]=1;cout<<G.vertices[v].data<<" ";ArcNode *x;x=(ArcNode*)malloc(sizeof(ArcNode));if(!x) exit(-1);x=G.vertices[v].firstarc;int w;for (;x;x=x->nextarc){ w=x->adjvex;if(visited[w]==0)ylx_DFS(G,w); } }void ylx_DFSB (ALGraph G,int v)//深度搜索的边集{ visited[v]=1;ArcNode *y;y=(ArcNode*)malloc(sizeof(ArcNode));if(!y) exit(-1);y=G.vertices[v].firstarc;int u=G.vertices[v].data;int w;for(;y;y=y->nextarc){ w=y->adjvex;if(visited[w]==0){ cout<<u<<"--->"<<w<<endl;ylx_DFSB(G,w); } }}typedef struct QNode{ int data;QNode *next;}QNode,*QueuePtr;typedef struct{ QueuePtr front;QueuePtr rear;}LinkQueue;void ylx_InitQueue (LinkQueue &Q)//建立一个空队列{ Q.front=Q.rear=(QueuePtr)malloc(sizeof(QN ode));if(!Q.front) exit(-1);Q.front->next=NULL;}void ylx_EnQueue (LinkQueue &Q,int e)//进队{ QNode *p;p=(QNode*)malloc(sizeof(QNode));if(!p) exit(-1);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;//free(p);}int ylx_DeQueue (LinkQueue &Q,int &e)//出队{ if(Q.front==Q.rear)return -1;QNode *p;p=(QNode*)malloc(sizeof(QNode));if(!p) exit(-1);p=Q.front->next;e=p->data; Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return e;}int ylx_QueueEmpty (LinkQueue Q)//判断队列是否为空{ if(Q.front==Q.rear)return 1;return 0;}void ylx_BFS(ALGraph G,int v)//广度搜索{ int u;LinkQueue Q;InitQueue(Q);if(visited[v]==0){ visited[v]=1;cout<<G.vertices[v].data<<" ";ylx_EnQueue(Q,v);while(ylx_QueueEmpty(Q)!=1){ ylx_DeQueue(Q,u);ArcNode *z;z=(ArcNode*)malloc(sizeof(ArcNode));if(!z) exit(-1);z=G.vertices[u].firstarc;/* for(int w=z->adjvex;w>=0;w=z->nextarc->adjvex){ if(visited[w]==0){ visited[w]=1;cout<<w<<" ";EnQueue(Q,w); } }*/int w;for(;z;z=z->nextarc){ w=z->adjvex;if(visited[w]==0){visited[w]=1;cout<<w<<" ";EnQueue(Q,w); } } } } }void ylx_BFSB (ALGraph G,int v)//广度搜索的边集{ int u;LinkQueue Q;InitQueue(Q);if(visited[v]==0){ visited[v]=1;EnQueue(Q,v);while(ylx_QueueEmpty(Q)!=1){ ylx_DeQueue(Q,u);ArcNode *r;r=(ArcNode*)malloc(sizeof(ArcNode)); if(!r) exit(-1);r=G.vertices[u].firstarc;int w;for(;r!=NULL;r=r->nextarc){ w=r->adjvex;if(visited[w]==0){ visited[w]=1;cout<<u<<"--->"<<w<<endl;EnQueue(Q,w); } } } }}int main(){ int i;ALGraph G;ylx_CreateDG(G);int x;cout<<"请输入结点数:";cin>>x;cout<<"邻接表为:"<<endl;for(int j=1;j<=x;j++){ cout<<G.vertices[j].data<<" ";ArcNode *p;p=(ArcNode*)malloc(sizeof(ArcNode)); if(!p) exit(-1);p=G.vertices[j].firstarc; while(p){ cout<<p->adjvex<<" ";p=p->nextarc; }cout<<endl; }cout<<"请输入第一个要访问的结点序号:"<<endl;int n;cin>>n;for( i=0;i<30;i++)visited[i]=0;cout<<"广度搜索:"<<endl;ylx_BFS(G,n);for( i=0;i<30;i++)visited[i]=0;cout<<endl;cout<<"边集:"<<endl;ylx_BFSB(G,n);for( i=0;i<30;i++)visited[i]=0;cout<<"深度搜索:"<<endl;ylx_DFS(G,n);for( i=0;i<30;i++)visited[i]=0;cout<<endl;cout<<"边集:"<<endl;ylx_DFSB(G,n);//system("pause");return 0;}六、运行结果截图第一个实验第二个实验。

相关文档
最新文档