实验七:查找算法及其应用
数据结构实验七 查找
数据结构实验七查找数据结构实验七查找一、实验目的本实验旨在通过实际操作和编程实现不同查找算法,并对其进行性能比较。
二、实验内容1.线性查找算法2.二分查找算法3.插值查找算法4.哈希查找算法三、线性查找算法线性查找算法是最简单的查找算法之一,它的基本思想是从第一个元素开始逐个比较,直到找到目标元素或遍历完整个数组。
1.算法步骤:●从数组的第一个元素开始遍历,比较当前元素与目标元素是否相等。
●如果相等,则查找成功,返回当前元素的索引。
●如果不相等,继续遍历下一个元素,重复上述步骤,直到遍历完整个数组。
●如果遍历完数组仍未找到目标元素,则查找失败,返回.1.2.算法示例代码(Python):```def linear_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn .1```四、二分查找算法二分查找算法适用于有序数组,它通过每次将目标值与数组的中间元素进行比较,并根据比较结果缩小搜索范围。
1.算法步骤:●初始化左边界为数组的第一个元素的索引,右边界为数组的最后一个元素的索引。
●在每一次循环中,找到数组中间元素的索引(mid)。
●将目标值与中间元素进行比较:●如果相等,则查找成功,返回中间元素的索引。
●如果目标值大于中间元素,则说明目标值在中间元素的右侧,将左边界更新为mid + 1.●如果目标值小于中间元素,则说明目标值在中间元素的左侧,将右边界更新为mid ●1.●重复上述步骤,直到左边界大于右边界,表示查找失败。
2.算法示例代码(Python):```def binary_search(arr, target):left = 0right = len(arr) ●1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid ●1return .1```五、插值查找算法插值查找算法是对二分查找算法的改进,它通过根据目标值在数组中的分布情况,更准确地预测目标值的位置,从而提高查找效率。
查找算法在数据处理中的应用
查找算法在数据处理中的应用在当今数字化的时代,数据处理成为了各个领域中至关重要的任务。
从大型企业的数据库管理到个人电脑中的文件搜索,查找算法都发挥着关键作用。
查找算法,简单来说,就是在一组数据中找到特定元素或者满足特定条件的元素的方法。
在日常生活中,我们经常会用到查找操作。
比如在手机的通讯录中查找某个联系人,在电脑的文件夹中查找某个文件,这些看似简单的操作背后,都有查找算法在默默工作。
不同的查找算法有着不同的特点和适用场景,下面我们就来详细了解一下几种常见的查找算法。
顺序查找算法是最简单直观的一种查找算法。
它的基本思想是从数据的一端开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据集合。
这种算法的优点是实现简单,对于小型数据集合或者无序数据集合比较适用。
然而,它的缺点也很明显,当数据量较大时,查找效率会非常低,因为平均情况下需要比较大约一半的元素。
二分查找算法则是一种效率更高的查找算法,但它要求数据集合必须是有序的。
二分查找的基本思路是每次都将数据集合分成两部分,通过比较目标元素与中间元素的大小,确定目标元素所在的子集合,然后在该子集合中继续进行二分查找,直到找到目标元素或者确定目标元素不存在。
由于每次查找都能将搜索范围缩小一半,所以二分查找的时间复杂度为 O(log n),相比顺序查找有了显著的提高。
在实际应用中,二分查找常用于有序数组的查找,例如在已排序的考试成绩表中查找特定分数的学生。
哈希查找算法是一种通过计算哈希值来快速定位数据的方法。
它将数据元素通过一个特定的哈希函数映射到一个哈希表中,然后通过计算目标元素的哈希值,直接在哈希表中进行查找。
如果哈希函数设计得好,哈希查找的平均时间复杂度可以接近O(1),效率非常高。
但是,哈希函数可能会出现冲突,即不同的元素计算出相同的哈希值,这就需要通过一些解决冲突的方法来保证查找的正确性。
除了以上这些基本的查找算法,还有一些基于它们的改进和扩展算法,以及适用于特定数据结构的查找算法。
查找算法在实际应用中的选择与优化
查找算法在实际应用中的选择与优化在当今数字化的时代,数据的处理和检索变得日益重要。
无论是在庞大的数据库中寻找特定的信息,还是在程序中快速定位所需的元素,查找算法都扮演着关键的角色。
正确选择和优化查找算法,可以显著提高系统的性能和效率,为用户带来更好的体验。
查找算法的种类繁多,常见的有顺序查找、二分查找、哈希查找等。
每种算法都有其特点和适用场景。
顺序查找是最为简单直观的一种查找算法。
它依次遍历数据集合中的每个元素,直到找到目标元素或者遍历完整个集合。
这种算法的优点是实现简单,对于小型、无序的数据集合或者数据集合的元素分布没有明显规律的情况,是一种可行的选择。
然而,其缺点也很明显,当数据量较大时,查找效率会非常低。
二分查找则是一种在有序数据集合中进行高效查找的算法。
它通过不断将数据集合对半分割,逐步缩小查找范围,从而快速定位目标元素。
二分查找的效率很高,时间复杂度为 O(log n)。
但它的前提是数据集合必须是有序的,如果数据集合经常动态变化,维护其有序性可能会带来较大的开销。
哈希查找则是通过将关键码映射到一个固定的哈希表中,从而实现快速查找。
哈希查找的平均时间复杂度可以达到 O(1),效率极高。
但哈希函数的设计至关重要,如果哈希函数设计不好,可能会导致大量的哈希冲突,从而影响查找效率。
在实际应用中,选择合适的查找算法需要综合考虑多个因素。
首先是数据量的大小。
如果数据量较小,顺序查找可能就足够了;而对于大规模的数据,二分查找或哈希查找可能更合适。
其次是数据的分布和有序性。
如果数据本身有序,二分查找会是很好的选择;如果数据无序且分布较为随机,哈希查找可能更能发挥优势。
此外,数据的动态变化情况也需要考虑。
如果数据经常插入、删除和修改,那么维护有序性可能会比较困难,此时哈希查找可能更适合。
而如果数据的更新操作相对较少,而查找操作频繁,那么可以在数据初始化时将其排序,然后使用二分查找。
除了选择合适的查找算法,对算法进行优化也是提高查找效率的重要手段。
数据结构实验七 查找
数据结构实验七查找数据结构实验七查找第一章实验目的本实验旨在掌握查找算法的实现原理及应用,深入理解各种查找算法的性能特点。
第二章实验内容1.实现顺序查找算法。
2.实现二分查找算法。
3.实现哈希查找算法。
4.实现二叉排序树查找算法。
5.实现平衡二叉树查找算法。
6.实现B+树查找算法。
7.使用不同的查找算法对随机的数据集进行查找,并比较它们的查找效率。
第三章实验步骤及详解1.顺序查找算法实现1..定义一个函数来实现顺序查找算法。
2..从待查找的数组的第一个元素开始遍历,逐个与目标元素进行比较。
3..如果找到目标元素,返回元素所在的位置索引。
4..如果遍历完整个数组仍未找到目标元素,返回-1表示未找到。
2.二分查找算法实现1..定义一个函数来实现二分查找算法。
2..对有序数组进行查找,首先确定查找范围的左右边界。
3..取查找范围的中间元素与目标元素进行比较。
4..如果相等,返回中间元素所在的位置索引。
5..如果目标元素小于中间元素,说明目标元素在左半部分,更新右边界。
6..如果目标元素大于中间元素,说明目标元素在右半部分,更新左边界。
7..继续迭代直到找到目标元素或者查找范围为空。
3.哈希查找算法实现1..定义一个哈希表数据结构。
2..将待查找的元素通过哈希函数转换为哈希值。
3..使用哈希值作为索引在哈希表中查找元素。
4..如果找到目标元素,返回元素所在的位置索引。
5..如果哈希表中对应的位置为空或者不匹配目标元素,表示未找到。
4.二叉排序树查找算法实现1..定义一个二叉树数据结构。
2..将待查找的元素按照大小依次插入二叉排序树中。
3..如果待查找的元素与当前节点相等,返回当前节点。
4..如果待查找的元素小于当前节点,继续在当前节点的左子树中查找。
5..如果待查找的元素大于当前节点,继续在当前节点的右子树中查找。
6..如果遍历完整个二叉排序树仍未找到目标元素,返回空指针表示未找到。
5.平衡二叉树查找算法实现1..定义一个平衡二叉树数据结构。
查找与及其应用实验报告
{printf("%d ",R[i].key);i++; //从表头往后找}if (i>=n)return -1;else{printf("%d",R[i].key);return i;}}int main(){SeqList R;int n=10,i;KeyType k=5;int a[]={3,6,2,10,1,8,5,7,4,9};for (i=0;i<n;i++) //建立顺序表R[i].key=a[i];printf("关键字序列:");for (i=0;i<n;i++)printf("%d ",R[i].key);printf("\n");printf("查找%d所比较的关键字:\n\t",k);if ((i=SeqSearch(R,n,k))!=-1)printf("\n元素%d的位置是%d\n",k,i);elseprintf("\n元素%d不在表中\n",k);printf("\n");}代码片段2:#include <stdio.h>#define MAXL 100//定义表中最多记录个数typedef int KeyType;typedef char InfoType[10];typedef struct{KeyType key;//KeyType为关键字的数据类型InfoType data;//其他数据} NodeType;typedef NodeType SeqList[MAXL];//顺序表类型int BinSearch(SeqList R,int n,KeyType k)//二分查找算法{int low=0,high=n-1,mid,count=0;while (low<=high){mid=(low+high)/2;printf("第%d次比较:在[%d,%d]中比较元素R[%d]:%d\n",++count,low,high,mid,R[mid].key);if (R[mid].key==k)//查找成功返回return mid;if (R[mid].key>k)//继续在R[low..mid-1]中查找high=mid-1;elselow=mid+1;//继续在R[mid+1..high]中查找}return -1;}int main(){SeqList R;KeyType k=9;int a[]={1,2,3,4,5,6,7,8,9,10},i,n=10;for (i=0;i<n;i++)//建立顺序表R[i].key=a[i];printf("关键字序列:");for (i=0;i<n;i++)printf("%d ",R[i].key);printf("\n");printf("查找%d的比较过程如下:\n",k);if ((i=BinSearch(R,n,k))!=-1)printf("元素%d的位置是%d\n",k,i);elseprintf("元素%d不在表中\n",k);return 0;}代码片段3:#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef int KeyType;//定义关键字类型typedef char InfoType;typedef struct node //记录类型{KeyType key; //关键字项InfoType data; //其他数据域struct node *lchild, *rchild;//左右孩子指针} BSTNode;int path[MaxSize];//全局变量,用于存放路径void DispBST(BSTNode *b);//函数说明int InsertBST(BSTNode *&p, KeyType k);BSTNode *CreatBST(KeyType A[], int n);void DispBST(BSTNode *bt);int JudgeBST(BSTNode *bt);int SearchBST(BSTNode *bt, KeyType k);void Delete1(BSTNode *p, BSTNode *&r);void Delete(BSTNode *&p);int DeleteBST(BSTNode *&bt, KeyType k);int InsertBST(BSTNode *&p, KeyType k)//在以*p为根节点的BST中插入一个关键字为k的节点{if (p == NULL)//原树为空, 新插入的记录为根节点{p = (BSTNode *)malloc(sizeof(BSTNode));p->key = k; p->lchild = p->rchild = NULL;return 1;}else if (k == p->key)return 0;else if (k<p->key)return InsertBST(p->lchild, k);//插入到*p的左子树中elsereturn InsertBST(p->rchild, k); //插入到*p的右子树中}BSTNode *CreatBST(KeyType A[], int n)//由数组A中的关键字建立一棵二叉排序树{BSTNode *bt = NULL; //初始时bt为空树int i = 0;while (i<n)if (InsertBST(bt, A[i]) == 1)//将A[i]插入二叉排序树T中{printf(" 第%d步,插入%d:", i + 1, A[i]);DispBST(bt); printf("\n");i++;}return bt; //返回建立的二叉排序树的根指针}void DispBST(BSTNode *bt)//以括号表示法输出二叉排序树bt{if (bt != NULL){printf("%d", bt->key);if (bt->lchild != NULL || bt->rchild != NULL){printf("(");DispBST(bt->lchild);if (bt->rchild != NULL) printf(",");DispBST(bt->rchild);printf(")");}}}KeyType predt = -32767; //predt为全局变量,保存当前节点中序前趋的值,初值为-∞int JudgeBST(BSTNode *bt)//判断bt是否为BST{int b1, b2;if (bt == NULL) //空二叉树是排序二叉树return 1;else{b1 = JudgeBST(bt->lchild); //返回对左子树的判断,不是返回0,否则返回1if (b1 == 0 || predt >= bt->key) //当左子树不是二叉排序树,或中序前趋(全局变量)大于当前根结点时return 0; //返回“不是二叉排序树”predt = bt->key; //记录当前根为右子树的中序前趋b2 = JudgeBST(bt->rchild); //对右子树进行判断return b2;}}int SearchBST(BSTNode *bt, KeyType k)//以递归方式输出从根节点到查找到的节点的路径{if (bt == NULL)return 0;else if (k == bt->key){printf("%3d", bt->key);return 1;}else if (k<bt->key)SearchBST(bt->lchild, k); //在左子树中递归查找elseSearchBST(bt->rchild, k); //在右子树中递归查找printf("%3d", bt->key);}void Delete1(BSTNode *p, BSTNode *&r)//当被删*p节点有左右子树时的删除过程{BSTNode *q;if (r->rchild != NULL)Delete1(p, r->rchild);//递归找最右下节点else//找到了最右下节点*r{p->key = r->key;//将*r的关键字值赋给*pq = r;r = r->lchild;//将*r的双亲节点的右孩子节点改为*r的左孩子节点free(q);//释放原*r的空间}}void Delete(BSTNode *&p)//从二叉排序树中删除*p节点{BSTNode *q;if (p->rchild == NULL)//*p节点没有右子树的情况{q = p; p = p->lchild; free(q);}else if (p->lchild == NULL)//*p节点没有左子树的情况{q = p; p = p->rchild; free(q);}else Delete1(p, p->lchild);//*p节点既有左子树又有右子树的情况}int DeleteBST(BSTNode *&bt, KeyType k)//在bt中删除关键字为k的节点{if (bt == NULL) return 0;//空树删除失败else{if (k<bt->key)return DeleteBST(bt->lchild, k);//递归在左子树中删除关键字为k的节点else if (k>bt->key)return DeleteBST(bt->rchild, k);//递归在右子树中删除关键字为k的节点else//k=bt->key的情况{Delete(bt);//调用Delete(bt)函数删除*bt节点return 1;}}}int main(){BSTNode *bt;KeyType k = 6;int a[] = { 4, 9, 0, 1, 8, 6, 3, 5, 2, 7 }, n = 10;printf("创建一棵BST树:");printf("\n");bt = CreatBST(a, n);printf("BST:"); DispBST(bt); printf("\n");printf("bt%s\n", (JudgeBST(bt) ? "是一棵BST" : "不是一棵BST"));printf(" 查找%d关键字(递归,逆序):", k); SearchBST(bt, k);//SearchBST(bt, k, path, -1);printf("\n删除操作:\n");printf(" 原BST:"); DispBST(bt); printf("\n");printf(" 删除节点4:");DeleteBST(bt, 4);DispBST(bt); printf("\n");printf(" 删除节点5:");实验结果:1.2.3:总结体会:通过本次实验学会了顺序查找和二分查找的区别,认清了两种方法的不同之处,相比之下,二分查找比顺序查找更能节约空间和时间,利用二分查找要优越与顺序查找,也更符合人们的思想,对排序的算法有了更深的认识,体会到了算法的优越。
查找和排序算法的实现(实验七)
实验七查找和排序算法的实现一.实验目的及要求(1)学生在实验中体会各种查找和内部排序算法的基本思想、适用场合,理解开发高效算法的可能性和寻找、构造高效算法的方法。
(2)掌握运用查找和排序解决一些实际应用问题。
二.实验内容:(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。
(2)编程实现一种内部排序算法(如插入排序、快速排序等)。
三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。
➢程序代码:折半查找:头文件:#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define maxlength 20typedef int ElemType;typedef struct{ElemType key;ElemType other;}card;//每条记录包含的数据项typedef struct{card r[maxlength];int length;}SSTable;//一张表中包含的记录容量void Create(SSTable &L);int Search(SSTable L,int elem);功能函数:#include"1.h"#include"stdio.h"void Create(SSTable &L){printf("新的线性表已经创建,请确定元素个数(不超过20)\n");scanf("%d",&L.length);printf("请按递增序列输入具体的相应个数的整数元素(空格隔开)\n");for(int i=0;i<L.length;i++){scanf("%d",&L.r[i].key);}}int Search(SSTable L,int elem){if(L.r[L.length-1].key<elem||L.r[0].key>elem){printf("表中没有该元素(不在范围内)\n");return 0;}int low=0,high=L.length-1;int mid;while(low<=high){mid=(low+high)/2;if(EQ(L.r[mid].key,elem)){printf("该元素在第%d位\n",mid+1); return 0;}else if(LT(elem,L.r[mid].key)){high=mid-1;}else{low=mid+1;}}printf("表中没有该元素(不在范围内)\n");return 0;}主函数:#include"stdio.h"#include"1.h"int main(){SSTable L;Create(L);printf("\n");printf("此时的线性表元素:\n");for(int a=0;a<L.length;a++){printf("%d ",L.r[a].key);}printf("\n");printf("\n");int elem;do{printf("请输入要查找的元素(输入000表示结束程序)\n");scanf("%d",&elem);if(elem!=000){Search(L,elem);}}while(elem!=000);return 0;}➢运行结果:(2)编程实现一种内部排序算法(如插入排序、快速排序等)。
C语言技术中的查找算法应用技巧
C语言技术中的查找算法应用技巧在计算机科学中,查找算法是一种用于在数据集合中寻找特定元素的方法。
在C语言编程中,掌握查找算法的应用技巧对于提高程序的效率和性能非常重要。
本文将介绍几种常见的查找算法,并探讨它们在C语言技术中的应用技巧。
1. 顺序查找算法顺序查找算法是最简单的一种查找方法。
它的基本思想是逐个比较待查找元素和数据集合中的每个元素,直到找到匹配的元素或遍历完整个数据集合。
在C语言中,可以使用for循环来实现顺序查找算法。
2. 二分查找算法二分查找算法是一种高效的查找方法,但是它要求数据集合必须是有序的。
它的基本思想是将待查找元素与数据集合的中间元素进行比较,如果相等则找到了匹配元素,如果待查找元素小于中间元素,则在数据集合的前半部分继续查找,如果待查找元素大于中间元素,则在数据集合的后半部分继续查找。
通过不断地二分,最终可以找到匹配的元素或确定元素不存在。
在C语言中,可以使用递归或循环来实现二分查找算法。
3. 哈希查找算法哈希查找算法是一种利用哈希函数快速定位元素的查找方法。
它的基本思想是将待查找元素通过哈希函数转换成一个索引,然后在索引对应的位置进行查找。
哈希查找算法的优势在于可以在常数时间内定位元素,但是它要求哈希函数具有良好的性质,避免冲突。
在C语言中,可以使用哈希表来实现哈希查找算法。
4. 二叉查找树二叉查找树是一种基于二叉树结构的查找方法。
它的基本思想是将数据集合构建成一个二叉树,使得每个节点的左子树中的元素小于节点的值,右子树中的元素大于节点的值。
通过比较待查找元素与节点的值,可以确定在左子树或右子树中继续查找。
二叉查找树可以通过递归或循环来实现。
在C语言中,可以使用指针和结构体来表示二叉查找树。
5. B树B树是一种多路搜索树,它的每个节点可以包含多个元素。
B树的基本思想是通过将数据集合分割成多个节点,使得每个节点中的元素有序,并且每个节点的元素个数在一个范围内。
通过比较待查找元素与节点中的元素,可以确定在子节点中继续查找。
查找算法实验报告
查找算法实验报告查找算法实验报告一、引言查找算法是计算机科学中的一个重要概念,它在数据处理和信息检索中起着关键作用。
本实验旨在探究几种常见的查找算法,并对它们的性能进行比较和分析。
二、顺序查找算法顺序查找算法是最简单直观的一种查找方法,它逐个比较待查找元素与数据集中的元素,直到找到匹配项或遍历完整个数据集。
该算法的时间复杂度为O(n),其中n为数据集的大小。
尽管顺序查找算法的效率较低,但在小规模数据集或无序数据集中仍然具有一定的应用价值。
三、二分查找算法二分查找算法是一种高效的查找算法,它要求数据集必须是有序的。
该算法通过将待查找元素与数据集的中间元素进行比较,从而将查找范围缩小一半。
如果中间元素与待查找元素相等,则查找成功;如果中间元素大于待查找元素,则在左半部分继续查找;如果中间元素小于待查找元素,则在右半部分继续查找。
通过不断缩小查找范围,二分查找算法的时间复杂度为O(log n),其中n为数据集的大小。
二分查找算法在大规模有序数据集中具有较高的查找效率。
四、哈希查找算法哈希查找算法是一种基于哈希表的查找方法,它通过将待查找元素映射到哈希表中的一个位置,从而快速定位到目标元素。
哈希查找算法的时间复杂度为O(1),即常数级别。
然而,哈希查找算法对哈希函数的选择和哈希冲突的处理有一定的要求。
如果哈希函数设计不合理或哈希冲突过多,可能会导致查找效率下降。
五、比较与分析在本实验中,我们对上述三种查找算法进行了性能比较和分析。
实验结果表明,在小规模数据集或无序数据集中,顺序查找算法的效率较高;而在大规模有序数据集中,二分查找算法的效率最高。
哈希查找算法虽然具有常数级别的时间复杂度,但在哈希函数和哈希冲突处理上需要额外的开销。
因此,在实际应用中,我们需要根据具体需求选择合适的查找算法。
六、实验总结通过本次实验,我们深入了解了查找算法的原理和应用。
顺序查找算法、二分查找算法和哈希查找算法各具特点,在不同场景下有不同的优劣势。
计算机算法查找
计算机算法查找计算机算法是计算机科学中的一个重要部分,用于解决各种问题。
其中,查找算法是最基本的算法之一,用于在一个数据集中查找特定的值。
在现代计算机科技中,查找算法已经成为普适的技术,其应用范围涵盖各种领域,如网页搜索、数据库查询、语音识别、人脸识别等。
本文将详细介绍计算机算法查找的原理、分类及应用。
一、算法查找的原理算法查找的核心思想是找到一个数据集中的某个指定值。
在这个过程中,计算机需要完成以下几个步骤:1.确定查找的目标值。
2.根据查找策略选择合适的算法。
3.按照算法规定的方式查找目标值。
4.如果找到目标值,输出其位置或者具体数值;如果没有找到,输出没有找到的结果。
二、算法查找的分类目前,算法查找主要分为线性查找和二分查找两种方式。
1.线性查找:线性查找也被称为顺序查找,它的核心思想是从数据集的第一个元素开始逐个扫描,直到找到指定的元素为止。
线性查找的优点是算法实现较为简单,适用于数据量比较小的情况。
它的缺点是在数据集比较大时,查找的时间复杂度会非常高,不适用于大数据集的查找。
2.二分查找:二分查找是一种较为高效的查找算法,它基于数据集已经排好序的假设,采用分治的思想,将数据集快速缩小到目标值所在的范围。
二分查找的优点是算法效率高,适用于数据集很大的情况。
它的缺点是要求数据集已经排好序,而且算法实现相对复杂。
三、算法查找的应用算法查找在现代科技中应用十分广泛,以下列举一些典型的应用场景。
1.网页搜索:网页搜索引擎是现代互联网中极为重要的应用之一,其中就使用了查找算法。
当用户输入关键词之后,搜索引擎需要在庞大的网页集合中查找与之相关的网页,然后按照相关程度返回结果。
为实现这个功能,搜索引擎需要采用多种不同的查找算法,如分词算法、正则匹配等。
2.数据库查询:数据库查询是现代系统中极为常见的功能之一。
数据库中存储的数据往往很多,而且需要多个条件进行筛选,查询效率直接影响系统的性能。
为了提高查询效率,数据库通常会采用查找算法来实现查询操作,如B+树索引、哈希表等。
比较常用查找算法的性能与应用场景
比较常用查找算法的性能与应用场景关键信息项1、所涉及的常用查找算法名称2、每种查找算法的性能指标(时间复杂度、空间复杂度等)3、不同应用场景的特点与需求4、各查找算法在不同场景下的优劣对比1、引言11 查找算法在计算机科学中的重要性查找算法是计算机程序设计中经常使用的基本操作之一,它在数据处理、数据库管理、搜索系统等领域都有着广泛的应用。
高效的查找算法能够显著提高程序的运行效率和性能。
12 协议目的本协议旨在对常用的查找算法进行性能比较,并分析它们在不同应用场景中的适用性,为开发者在选择合适的查找算法时提供参考依据。
2、常用查找算法概述21 顺序查找顺序查找是一种最简单的查找算法,它从数组的一端开始,逐个元素进行比较,直到找到目标元素或遍历完整个数组。
211 算法步骤依次比较数组中的每个元素与目标元素,若相等则查找成功,否则继续下一个元素。
212 时间复杂度在最坏情况下,时间复杂度为 O(n),其中 n 是数组的长度。
213 空间复杂度O(1),只需要常数级的额外空间。
22 二分查找二分查找适用于有序数组,通过不断将数组中间的元素与目标元素进行比较,缩小查找范围,直到找到目标元素。
221 算法步骤首先将数组中间的元素与目标元素进行比较,如果相等则查找成功;如果目标元素小于中间元素,则在左半部分继续查找;否则在右半部分继续查找。
重复这个过程,直到找到目标元素或确定目标元素不存在。
222 时间复杂度O(log n),其中 n 是数组的长度。
223 空间复杂度O(1)23 哈希查找哈希查找通过将元素映射到一个哈希表中,利用哈希函数快速定位目标元素。
231 算法步骤计算目标元素的哈希值,在哈希表中查找对应的位置,如果该位置存在元素且与目标元素相等,则查找成功;否则可能发生哈希冲突,需要通过解决冲突的方法进一步查找。
232 时间复杂度在理想情况下,平均时间复杂度为 O(1),但在处理哈希冲突时可能会增加时间复杂度。
查找、排序的应用 实验报告
实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。
2、学会比较各种排序与查找算法的优劣。
3、学会针对所给问题选用最适合的算法。
4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。
二、实验内容[问题描述]对学生的基本信息进行管理。
[基本要求]设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。
要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。
[测试数据]由学生依据软件工程的测试技术自己确定。
三、实验前的准备工作1、掌握哈希表的定义,哈希函数的构造方法。
2、掌握一些常用的查找方法。
1、掌握几种常用的排序方法。
2、掌握直接排序方法。
四、实验报告要求1、实验报告要按照实验报告格式规范书写。
2、实验上要写出多批测试数据的运行结果。
3、结合运行结果,对程序进行分析。
五、算法设计a、折半查找设表长为n,low、high和mid分别指向待查元素所在区间的下界、上界和中点,key为给定值。
初始时,令low=1,high=n,mid=(low+high)/2,让key与mid指向的记录比较,若key==r[mid].key,查找成功若key<r[mid].key,则high=mid-1若key>r[mid].key,则low=mid+1重复上述操作,直至low>high时,查找失败b、顺序查找从表的一端开始逐个进行记录的关键字和给定值的比较。
在这里从表尾开始并把下标为0的作为哨兵。
void chaxun(SqList &ST) //查询信息{ cout<<"\n************************"<<endl;cout<<"~ (1)根据学号查询 ~"<<endl;cout<<"~ (2)根据姓名查询 ~"<<endl;cout<<"~ (3)根据性别查询 ~"<<endl;cout<<"~ (4)退出 ~"<<endl;cout<<"************************"<<endl; if(m==1) 折半查找算法:for(int i=1;i<ST.length;i++)//使学号变为有序for(int j=i;j>=1;j--)if(ST.r[j].xuehao<ST.r[j-1].xuehao){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}int a=0;cout<<"输入要查找的学号"<<endl;cin>>n;int low,high,mid;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].xuehao){cout<<ST.r[mid].xuehao<<""<<ST.r[mid].xingming<<""<<ST.r[mid].xingbei<<""<<ST.r[mid].chengji1<<""<<ST.r[mid].chengji2<<""<<ST.r[mid].zong<<endl;a=1;break;}else if(n<ST.r[mid].xuehao )high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找顺序查找算法:cout<<"输入要查找的姓名"<<endl;cin>>name;for(int i=0;i<ST.length;i++){if(name==ST.r[i].xingming){cout<<ST.r[i].xuehao<<""<<ST.r[i].xingming<<""<<ST.r[i].xingbei<<""<<ST.r[i].chengji1<<""<<ST.r[i].chengji2<<""<<ST.r[i].zong<<endl;a=1;}1、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。
数据结构实验七 查找
数据结构实验七查找在计算机科学中,数据结构是组织和存储数据的方式,而查找则是在给定的数据结构中寻找特定元素的操作。
本次实验七的重点就是深入研究查找这一重要的数据处理操作。
查找操作在我们日常生活和计算机程序中无处不在。
想象一下在电话簿中查找一个朋友的号码,或者在图书馆的书架中寻找一本书,这都是查找的实际应用场景。
在计算机程序中,当我们需要从大量数据中快速找到所需的信息时,高效的查找算法就显得至关重要。
常见的查找算法有顺序查找、二分查找、哈希查找等。
顺序查找是最简单直接的方法,它从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据结构。
这种方法适用于数据量较小或者数据未排序的情况。
让我们通过一个简单的示例来理解顺序查找。
假设有一个整数数组5, 3, 8, 2, 9,我们要查找数字 8。
从数组的第一个元素 5 开始,依次与8 进行比较。
当比较到第三个元素时,找到了目标数字 8,查找结束。
虽然顺序查找的思路简单,但在数据量较大时,它的效率相对较低。
与顺序查找不同,二分查找则要求数据是有序的。
它通过不断将待查找的区间一分为二,逐步缩小查找范围,从而提高查找效率。
还是以整数数组为例,比如 2, 4, 6, 8, 10 要查找数字 6。
首先,比较中间元素 6 和目标数字 6,正好相等,查找成功。
如果要查找的数字小于中间元素,则在左半区间继续查找;如果大于中间元素,则在右半区间查找。
二分查找的效率在有序数据中表现出色。
然而,如果数据经常变动,需要频繁进行插入和删除操作,维护数据的有序性可能会带来较大的开销。
哈希查找则是另一种常见的查找方法。
它通过一个哈希函数将关键字映射到一个特定的位置,从而实现快速查找。
哈希函数的设计至关重要,如果设计不当,可能会导致大量的冲突,影响查找效率。
在实际应用中,选择合适的查找算法取决于多种因素,如数据的规模、数据的分布特征、查找的频繁程度以及对时间和空间复杂度的要求等。
常用查找算法及其实践应用
常用查找算法及其实践应用查找算法是计算机科学中的一类基本算法,用于在一组数据中快速查找目标值。
本文将介绍常用的查找算法及其实践应用,并讨论它们的优缺点。
一、线性查找算法线性查找算法,也称作顺序查找算法,是最简单直接的查找算法之一。
它通过逐个比较数据元素,直到找到目标值或搜索整个数据集。
实践应用:线性查找算法适用于数据量较小且无序的情况。
例如,在一个未排序的数组中查找一个特定的值。
二、二分查找算法二分查找算法,也称作折半查找算法,是一种高效的查找算法。
它将目标值与数据集的中间值进行比较,根据比较结果将搜索范围缩小一半,以此类推,直到找到目标值或搜索范围为空。
实践应用:二分查找算法适用于已排序的数据集。
比如,在一个有序数组中查找一个特定的值。
三、哈希查找算法哈希查找算法通过哈希函数将数据映射到一个固定的位置,然后在该位置进行查找。
它的平均查找时间复杂度为O(1),具有高效的查找速度。
实践应用:哈希查找算法适用于查找大规模数据集中的特定值。
它常被用于数据库索引、缓存系统等。
四、二叉查找树算法二叉查找树算法,也称作二叉搜索树算法,是一种基于二叉树的查找算法。
它具有以下特点:左子树的所有节点小于根节点,右子树的所有节点大于根节点。
通过比较目标值与根节点的大小关系,可以快速缩小搜索范围。
实践应用:二叉查找树算法适用于频繁插入和删除操作的场景。
它常被用于实现字典、关联数组等数据结构。
五、平衡查找树算法平衡查找树算法,如红黑树、AVL树等,是对二叉查找树的改进。
它通过调整节点的颜色和旋转操作来保持树的平衡,以确保查找效率的稳定性。
实践应用:平衡查找树算法适用于高效地处理大规模数据集的查找、插入和删除操作。
它常被用于数据库索引、编译器等领域。
六、后缀树算法后缀树算法是一种用于字符串查找的数据结构。
它将目标字符串的所有后缀都表示为树的节点,通过遍历树来查找目标字符串的子串。
实践应用:后缀树算法适用于文本搜索、模式匹配等领域。
查找算法的应用----哈希查找
一、实验名称:
查找算法的应用----哈希查找
二、实验目的:
1.进一步了解查找算法的用途;
2.进一步巩固哈希函数及哈希表等有关概念;
3.掌握哈希表的创建及查找的过程和方法;
4.比较哈希查找与其它查找算法的不同,体会哈希查找的优缺点。
三、实验内容:
任意给定N个元素,用除留余数法构造哈希函数,用线性探测再散列的方法建立哈希表,在哈希表中进行查找,并在屏幕上显示哈希表及查找结果。
求出等概率条件的平均查找长度,验证结果是否正确。
四、实验要求
1.哈希表中元素的类型为结构体类型。
2.输出哈希表的内容,验证其是否正确。
3.任意给定一个关键字进行查找,验证查找结果是否正确。
给定的这个关键字应有两类:存在和不存在。
4.求出等概率条件的平均查找长度。
五、实验程序代码:
完整的源程序。
六、实验数据处理及实验结果:
实验中输入的数据及执行结果
七、实验小结:
上机中出现的问题、解决方法,对所学知识的进一步理解,以后需要注意的问题等。
实验日期:年月日
交报告日期:年月日。
常用查找算法及其实践应用
常用查找算法及其实践应用查找是计算机科学中常见的操作之一,它的目标是在给定的数据集中寻找特定值或满足特定条件的数据。
常用的查找算法包括线性查找、二分查找、哈希查找和树结构查找等。
本文将对这些算法进行介绍,并探讨它们在实践中的应用。
一、线性查找算法线性查找算法,也称作顺序查找算法,是最简单的查找算法之一。
它的基本思想是逐个遍历数据集中的元素,直到找到目标元素或遍历完整个数据集。
线性查找的时间复杂度为O(n),其中n表示数据集中元素的个数。
线性查找算法的实践应用较为广泛,例如在一个无序数组中查找目标元素、在一个文本文档中搜索关键词等。
由于线性查找算法简单直观,因此在数据量较小或者数据无序的情况下,它是一种有效的查找方法。
二、二分查找算法二分查找算法是一种高效的有序数据查找算法,它的基本思想是通过将数据集划分为两个部分,确定目标元素在哪一部分中,从而快速缩小查找范围。
二分查找的时间复杂度为O(log n),其中n表示有序数据集中元素的个数。
二分查找算法在实践中广泛应用于有序数组或列表的查找操作。
例如,在电话号码簿、字典等有序数据集中查找目标记录,都可以使用二分查找来提高查找的效率。
三、哈希查找算法哈希查找算法是一种基于哈希表的查找方法,它通过将数据元素的关键字进行哈希运算,将其转化为对应的哈希地址,然后在哈希表中查找目标元素。
哈希查找的时间复杂度为O(1)或O(n),其中n表示哈希表中元素的个数。
哈希查找算法在实践中被广泛应用于大型数据库、搜索引擎等需要高效查找的场景。
它通过哈希函数将关键字映射到哈希表中,从而实现快速查找目标元素的目的。
四、树结构查找算法树结构查找算法基于树这种数据结构,它通过将数据集组织成树形结构,然后利用树的特性进行查找操作。
常见的树结构查找算法包括二叉搜索树、平衡二叉树、B树和红黑树等。
树结构查找算法在实践中被广泛应用于文件系统、数据库索引等领域。
例如,在文件系统中根据文件名查找文件、在数据库中根据索引字段查找记录都离不开树结构查找算法的支持。
常用查找算法及其实践应用
常用查找算法及其实践应用查找算法是计算机科学中一种重要的算法,用于在一组数据中查找指定的元素。
常用的查找算法包括顺序查找、二分查找、哈希查找等。
本文将介绍这些常用的查找算法,并探讨它们在实践中的应用。
一、顺序查找顺序查找是最简单的一种查找算法,其基本思想是逐个地比较数组中的元素,直到找到目标元素或者遍历完所有元素。
它适用于无序数组、链表等数据结构。
在实践应用中,顺序查找可以用于查找手机号码通讯录中某个人的联系方式、寻找某本书的索引号等。
虽然顺序查找的时间复杂度较高,但是对于小规模的数据集,其效率仍然可以接受。
二、二分查找二分查找是一种高效的查找算法,前提是数据必须有序。
它的基本思想是将待查找的数据与数组的中间元素进行比较,根据结果缩小查找范围,直到找到目标元素或者范围为空。
在实践应用中,二分查找可以用于在有序数组中查找特定元素,例如在一个升序排列的学生成绩列表中查找某个学生的成绩。
二分查找的时间复杂度为O(logn),相比于顺序查找,它的效率要高很多。
三、哈希查找哈希查找是利用哈希表进行查找的一种算法。
它通过将数据映射到哈希表中的某个位置来进行查找。
当发生哈希冲突时,可以通过链表或者其他方法解决。
在实践应用中,哈希查找广泛用于各种数据库、搜索引擎等系统中,可以快速定位到数据所在的位置,提高查找的效率。
但是它也有一些缺点,比如哈希函数的设计、哈希冲突的处理等问题需要关注。
四、实践应用举例1. 在图书馆管理系统中,通过书名或者作者名进行查找图书的功能,可以使用二分查找算法来实现。
首先将书籍按照书名或者作者名进行排序,然后利用二分查找快速定位到目标书籍的位置。
2. 在电商平台的商品搜索功能中,用户可以通过商品名称进行查找。
为了提高搜索的效率,可以使用哈希查找算法来构建商品名称到商品ID的映射关系,用户输入商品名称时,直接在哈希表中查找对应的商品ID,然后定位到商品详情页。
3. 在各类游戏中,查找某个玩家角色的信息是常见的操作。
详细解析常用查找算法及其实现
详细解析常用查找算法及其实现在计算机科学中,查找算法是一种用于在数据集合中查找特定元素的方法。
查找算法的效率和性能对于许多应用程序至关重要,例如数据库管理、搜索引擎和数据处理等。
本文将详细解析几种常用的查找算法,并探讨它们的实现方式和特点。
一、顺序查找顺序查找是最简单的查找算法之一。
它的基本思想是从数据集合的开头开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据集合。
以下是顺序查找的 Python 代码实现:```pythondef sequential_search(arr, target):for i in range(len(arr)):if arri == target:return ireturn -1```顺序查找的时间复杂度为$O(n)$,其中$n$ 是数据集合的大小。
这意味着在最坏情况下,需要遍历整个数据集合才能找到目标元素。
然而,顺序查找的优点是实现简单,对于小型数据集合或者数据集合的顺序不重要的情况,它是一种可行的选择。
二、二分查找二分查找是一种在有序数据集合中进行查找的高效算法。
它的基本思想是通过不断将数据集合对半分割,比较目标元素与中间元素的大小,从而缩小查找范围,直到找到目标元素或者确定目标元素不存在。
以下是二分查找的 Python 代码实现:```pythondef binary_search(arr, target):low = 0high = len(arr) 1while low <= high:mid =(low + high) // 2if arrmid == target:return midelif arrmid < target:low = mid + 1else:high = mid 1return -1```二分查找的时间复杂度为$O(\log n)$,这使得它在大型有序数据集合中的查找效率非常高。
但是,二分查找要求数据集合必须是有序的,如果数据集合无序,需要先进行排序操作,这可能会增加额外的时间开销。
实验报告7-查找算法
试着自己编写剩余代码,对以下顺序有序序列进行二分查找:
inta[16]={2,4,5,7,8,11,23,26,30,36,39,40,41,45,58,67};
#include<iostream>
usingnamespacestd;
voidSearch(inta[],intbegin,intend,intx)
主要代码如下:
while(begin <= end)
{
i = (begin + end) / 2;
if (x==a[i])
{
printf("数据%d已找到,在第%d个位置\n",x,i+1);
bfinded = true;
break;
}
else
if (x<a[i])
end = i - 1;
else
begin = i + 1;
实 验 总 结(结果和心得体会)
排序的算法很多,但是时间复杂度及空间复杂度不尽相同,算法复杂度越低越好;像二分查找比顺序查找好。
若r[mid].key=k,则查找成功,返回该结点的位置mid;
若r[mid].key<k,Fra bibliotek说明待查找的结点只可能在有序表的右子表中,接着只要在其右子表中继续进行二分查找即可;
若r[mid].key>k,则说明待查找的结点只可能在有序表的左子表中,接着只要在其左子表中继续进行二分查找即可。
这样每经过一次比较,就缩小一半查找范围,如此进行下去,直到找到关键字为k的结点或当前查找区间为空(即查找失败,条件是high<low)时为止。
low=mid+1;
}
if(low>high) cout<<x<<" is not found."<<endl;
查找及应用实验报告
实验名称:查找及应用一、实验目的1. 掌握查找数据的基本方法。
2. 学会使用数据库查询语言进行数据查找。
3. 熟悉应用查找结果进行数据分析。
二、实验环境1. 操作系统:Windows 102. 数据库管理系统:MySQL 5.73. 开发工具:MySQL Workbench三、实验内容1. 数据库设计2. 数据插入3. 数据查找4. 数据分析四、实验步骤1. 数据库设计(1)创建数据库CREATE DATABASE test_db;(2)创建表CREATE TABLE student (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50),age INT,class VARCHAR(50));2. 数据插入INSERT INTO student (name, age, class) VALUES ('张三', 20, '计算机科学与技术');INSERT INTO student (name, age, class) VALUES ('李四', 22, '软件工程');INSERT INTO student (name, age, class) VALUES ('王五', 21, '网络工程');INSERT INTO student (name, age, class) VALUES ('赵六', 23, '电子工程');3. 数据查找(1)使用SELECT语句查询学生信息SELECT FROM student;(2)使用WHERE子句进行条件查询SELECT FROM student WHERE age > 21;(3)使用LIKE子句进行模糊查询SELECT FROM student WHERE name LIKE '李%';4. 数据分析(1)统计每个班级的学生人数SELECT class, COUNT() AS student_count FROM student GROUP BY class;(2)查询年龄最大的学生信息SELECT FROM student ORDER BY age DESC LIMIT 1;五、实验结果与分析1. 实验结果(1)数据库设计CREATE DATABASE test_db;CREATE TABLE student (id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(50),age INT,class VARCHAR(50));(2)数据插入INSERT INTO student (name, age, class) VALUES ('张三', 20, '计算机科学与技术');INSERT INTO student (name, age, class) VALUES ('李四', 22, '软件工程');INSERT INTO student (name, age, class) VALUES ('王五', 21, '网络工程');INSERT INTO student (name, age, class) VALUES ('赵六', 23, '电子工程');(3)数据查找SELECT FROM student;SELECT FROM student WHERE age > 21;SELECT FROM student WHERE name LIKE '李%';(4)数据分析SELECT class, COUNT() AS student_count FROM student GROUP BY class;SELECT FROM student ORDER BY age DESC LIMIT 1;2. 实验分析通过本次实验,我们掌握了以下内容:(1)数据库设计:了解数据库的基本概念,学会创建数据库和表,以及设置表结构。
实验七 查找
实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。
2、学会比较各种排序与查找算法的优劣。
3、学会针对所给问题选用最适合的算法。
4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。
二、实验内容[问题描述]对学生的基本信息进行管理。
[基本要求]设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。
要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。
三.主要功能:实现学生成绩的录入,并分别按照学号,姓名和性别进行查询,按照成绩1,2和总成绩分别排序。
四.主要实现函数1.折半查找for(i=1;i<ST.length;i++){for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}2.顺序查找=0;cout<<"输入要查找的姓名"<<endl;cin>>name;for(i=0;i<ST.length;i++)if(name==ST.r[i].name){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}3.选择法排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].sum>ST.r[j].sum){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;五.源程序#include <iostream>#include<string>#include <iomanip>using namespace std;#define MAXSIZE 100typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu(){int i;cout<<" /////////////////////////////////////////////////"<<endl;cout<<" 学生信息管理系统\n "<<endl;cout<<" /////////////////////////////////////////////////"<<endl; cout<<" 1.输入成绩"<<endl;cout<<" 2.查询成绩"<<endl;cout<<" 3.成绩排序"<<endl;cout<<" 4.退出"<<endl;cout<<"请选择1-4:"<<endl;cin>>i;while(i<0||i>4){cout<<"对不起,您输入错误!"<<endl; //提示输入是否错误cout<<"请重新输入1-4: "<<endl;cin>>i;}return i;}void CreatList(SqList &ST) //创建学生的相关信息{cout<<"请输入学生的个数"<<endl;cin>>ST.length;cout<<" 学号姓名性别班级成绩1 成绩2 "<<endl;for(int i=0;i<ST.length;i++){cout<<"输入第"<<i+1<<"学生的信息"<<endl;cin>>ST.r[i].num>>ST.r[i].name>>ST.r[i].sex>>ST.r[i].className>>ST.r[i].mar k1>>ST.r[i].mark2;}cout<<"完成输入"<<endl;}void output(SqList &ST)//输出{cout<<"学生的信息如下"<<endl;cout<<" 学号姓名性别班级成绩1 成绩2 总分"<<endl;for(int i=0;i<ST.length;i++)cout<<setw(6)<<ST.r[i].num<<setw(6)<<ST.r[i].name<<setw(6)<<ST.r[i].sex<<se tw(6)<<ST.r[i].className<<setw(8)<<ST.r[i].mark1<<setw(8)<<ST.r[i].mark2<<setw( 8)<<ST.r[i].mark1+ST.r[i].mark2<<" "<<endl;}void Query(SqList &ST) //查询信息{cout<<endl;cout<<" (1)根据学号查询"<<endl;cout<<" (2)根据姓名查询"<<endl;cout<<" (3)根据性别查询"<<endl;cout<<" (4)退出"<<endl;int a,m,n,i,j;int low,high,mid;DataType LI; //使学号变为有序string name;string xb;cin>>m;switch(m){case 1: //折半查找for(i=1;i<ST.length;i++){for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}}a=0;cout<<"输入要查找的学号"<<endl;cin>>n;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].num){cout<<ST.r[mid].num<<" "<<ST.r[mid].name<<" "<<ST.r[mid].sex<<" "<<ST.r[mid].className<<" "<<ST.r[mid].mark1<<" "<<ST.r[mid].mark2<<" "<<(ST.r[mid].mark1+ST.r[mid].mark2)<<endl;a=1;break;}else if(n<ST.r[mid].num)high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;case 2: //顺序查找{a=0;cout<<"输入要查找的姓名"<<endl;cin>>name;for(i=0;i<ST.length;i++){if(name==ST.r[i].name){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 3: //顺序查找{a=0;cout<<"输入要查找性别"<<endl;cin>>xb;for(i=0;i<ST.length;i++){if(xb==ST.r[i].sex){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 4:menu();break;}}void sort(SqList &ST) //排序{int n,i,j;DataType LI; //定义存储学号向量cout<<endl;cout<<" (1)根据学号排序" <<endl;cout<<" (2)根据成绩1排序"<<endl;cout<<" (3)根据成绩2排序"<<endl;cout<<" (4)根据总成绩排序"<<endl;cout<<" (5)退出"<<endl;cin>>n;switch(n){case 1: //按学号排序,使用插入排序for(i=1;i<ST.length;i++)for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}output(ST);cout<<"排序成功"<<endl;break;case 2: //按成绩1排序,用选择排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark1>ST.r[j].mark1){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序成功"<<endl;break;case 3: // 根据成绩2排序,使用选择法排for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark2>ST.r[j].mark2){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}output(ST);cout<<"排序成功"<<endl;break;case 4: //根据总成绩排序,使用选择法排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].sum>ST.r[j].sum){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序成功"<<endl;break;case 5: //退出menu();break;}}}void main(){SqList ST;while(1){switch(menu()){case 1:cout<<endl;cout<<" "<<endl;cout<<" 1.成绩的输入 "<<endl;cout<<" "<<endl;CreatList(ST);break;case 2:cout<<" "<<endl;cout<<" 2.成绩的查询 "<<endl;cout<<" "<<endl;Query(ST);break;case 3:cout<<" "<<endl;cout<<" 3.成绩的排序 "<<endl;cout<<" "<<endl;sort(ST);break;case 4:cout<<" "<<endl;cout<<" 4.退出 "<<endl;cout<<" "<<endl;exit(0);break;}}}六运行界面1.主界面2.输入界面3.按学号查询界面4.按姓名查询5.按性别查询6.按成绩1排序7.按成绩28.总成绩。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
陕西科技大学实验报告
班级物联网121 学号2 0 1 2 0 6 1 0 0 1 2 8 姓名张奇实验组别
实验日期2014年6月13日室温报告日期2014年6月13日成绩
报告内容:(目的和要求、原理、步骤、数据、计算、小结等)
实验名称:查找算法及其应用
一、实验目的
1、掌握查找折半查找、顺序查算法的概念。
2、熟练运用C语言实现折半查找、顺序查算法的基本操作。
3、在掌握查找算法基本操作的基础上,能够用查找算法解决简单问题。
二、实验环境
Microsoft Visual C++ 6.0
三、实验要求
编写程序测试这折半查找、顺序查算法。
四、实验原理
1、折半查找又称二分查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。
因此,折半查找方法适用于不经常变动而查找频繁的有序列表。
首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。
重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。
算法要求必须采用顺序存储结构以及必须按关键字大小有序排列。
2、顺序查找过程:从表中的最后一个记录开始,逐个进行记录的关键字与给定值进行比较,若某个记录的关键字与给定值相等,则查找成功,找到所查的记录;反之,若直到第一个记录,其关键字和给定值比较都不相等,则表明表中没有所查的记录,查找失败。
五、实验方案
具体参照下页流程图。
六、实验代码
#include"stdio.h"
typedef int KeyType; //定义关键字类型
typedef struct{ //定义数据元素类型
KeyType key;
}DataType;
#define LISTSIZE 100 //定义静态查找表类型
typedef struct{
DataType items[LISTSIZE];
int length;
}SqList;
/*顺序查找算法*/
int SeqSearch(SqList L,DataType X) //L为静态查找表,X为待查找元素{
int i=L.length;
L.items[i].key=X.key; //设置监视哨
while(L.items[i].key!=X.key) i--;
return i;
}
/*折半查找算法*/
int BinarySearch(SqList L,DataType X) //L为静态查找表,X为待查找元素{
int low=0,upper=L.length-1,mid;
while (low<=upper)
{
mid=(low+upper)/2;
if(L.items[mid].key==X.key) return mid; //查找成功
if(L.items[mid].key<X.key) low=mid+1; //在后半子区间查找
else upper=mid-1; //在前半子区间查找}
return -1; //查找失败
}
int main ()
{
int i,pos;
SqList l;
DataType x;
printf("\n请输入顺序表的长度:");
scanf("%d",&l.length);
printf("\n请输入顺序表中的元素:\n");
for(i=0;i<l.length;i++)
printf("\n请输入要查找的数:");
scanf("%d",&x.key);
pos=SeqSearch(l,x);
printf("\n该数据在顺序表中的位置为:%d\n\n",pos-1);
return 0;
}
七、实验结果
八、实验小结
本次实验掌握查了找折半查找、顺序查算法的概念,运用C语言实现折半查找、顺序查算法的基本操作。
需要注意的是,折半查找算法要求必须采用顺序存储结构以及必须按关键字大小有序排列。
若定义的顺序表不是采用顺序存储结构或者不是有序排列,则查找结果会出错。