精华内容
下载资源
问答
  • 顺序检索的算法描述如下 int Search_Sequen(SSTable ST,KeyType key){ //在线性表ST中顺序检索其关键字等于Key的数据元素, //若找到,函数值为该元素在表中的位置,否则为-1. ST.element[ST.length].key=key; //...
  • 顺序查找算法

    千次阅读 2021-05-09 16:30:17
      顺序查找是按照序列原有顺序对数组进行遍历比较查询的基本查找算法。基本原理:对于任意一个序列以及一个给定的元素,将给定元素与序列中元素依次比较,直到找出与给定关键字相同的元素,或者将序列中的元素与其...

      顺序查找(Sequential Search)又称线性查找,是按照序列原有顺序对数组进行遍历比较查询的基本查找算法,它是一种最简单的查找方法。基本原理:对于任意一个序列以及一个给定的元素,将给定元素与序列中元素依次比较,直到找出与给定关键字相同的元素,或者将序列中的元素与其都比较完为止。

      对于没有排序的数据,只能使用顺序查找;如果数据已经排好序,可以使用速度比较快的折半查找(二分查找)。

      例如: 使用顺序查找算法在数组 { 4,2,8,0,5,7,1,3,6,9 } 中查找元素7。

    在这里插入图片描述
      实现代码如下所示。

    #include<iostream>
    using namespace std;
    
    int SequentialSearch(int *a, const int n, const int num)
    {
    	int i;
    	for (i = 0; i < n; i++)
    	{
    		if (a[i] == num)
    		{
    			return i;
    		}
    	}
    	if (i == n)
    	{
    		return -1;
    	}
    }
    
    int main()
    {
    	int a[] = { 4,2,8,0,5,7,1,3,6,9 };
    
    	int num = 7;
    	int result = SequentialSearch(a, 10, num);
    	if (result == -1)
    	{
    		cout << "未找到!" << endl;
    	}
    	else
    	{
    		cout << "在a[" << result << "]里找到" << num << endl;
    	}
    
    	system("pause");
    
    	return 0;
    }
    

    在a[5]里找到7

    展开全文
  • 顺序查找算法C语言源程序,顺序查找算法比较简单,即从数据序列的第一个元素开始,进行一一匹配操作,匹配成功则返回匹配结果。
  • C语言分块查找算法索引顺序查找算法 例如采用分块查找法在有序表 111218283956698996122135146156256298 中查找关键字为 96 的元素 査找特定关键字元素个数为 15要求用户输入有序表各元素程序输出査找成功与否若成功...
  • 顺序查找算法C语言实现

    千次阅读 2021-10-23 18:27:42
    顺序查找算法 实现思想:静态查找表用顺序存储结构表示时,顺序查找的查找过程为:从表中的最后一个数据元素开始,逐个同记录的关键字做比较,如果匹配成功,则查找成功;反之,如果直到表中第一个关键字查找完也...

    顺序查找算法

    实现思想:静态查找表用顺序存储结构表示时,顺序查找的查找过程为:从表中的最后一个数据元素开始,逐个同记录的关键字做比较,如果匹配成功,则查找成功;反之,如果直到表中第一个关键字查找完也没有成功匹配,则查找失败。
    应用场景:顺序查找一般理解为线性查找,一般针对数组或是链表,针对线性的数据存储结构实现,是最简单的查找算法。

    下面通过自己建立一个顺序表来进行数据查找。构建完整程序并进行代码逻辑分析。

    typedef struct {
        keyType key;//查找表中每个数据元素的值,注意KeyType可以是自定义数据类型或是普通数据类型
        //如果需要,还可以添加其他属性
    }ElemType;
    

    这个结构体主要用来存储数据,当我们创建一个需要存储数值的顺序表的时候就循环向这个结构中的keyType类型存储数据

    typedef struct{
        ElemType *elem;//存放查找表中数据元素的数组
        int length;//记录查找表中数据的总数量
    }SSTable;
    

    这个结构体用来定影你存储数据的结构体数组,并控制你存储数据的数组长度。

    //创建数据表
    void Create(SSTable *st,int length)
    {
            //(*st) = (SSTable *)malloc(sizeof(SSTable));
            st->length = length;
            st->elem = (ElemType *)malloc((length + 1)*sizeof(ElemType));
            printf("输入表中的数据元素:\n");
            //根据查找表中数据元素的总长度,在存储时,从数组下标为1的空间开始存储数据
            for (int i = 1;i<=length;i++)
            {
                    scanf("%d",&(st->elem[i].key));
            }
    }
    

    上面的代码会根据你传入的数组长度参数,进行数据表的创建

    int search_seq(SSTable *st,keyType key)
    {
            st->elem[0].key = key;    //将关键字作为一个数据元素放到查找表的第一个位置,起监视哨的作用
            int i = st->length;
            //从查找表的最后一个数据元素依次遍历,一直遍历到数组下标为0
            while(st->elem[i].key!=key)
            {
                    i--;
            }
            //如果 i = 0,说明查找失败,反之,返回的是含有关键字key的数据元素在查找表中的位置
            return i;
    }
    这是核心的查找接口,根据程序我们可以分析出会从数据表中最后一个数据依次往前面进行查询。
    

    下面是整体程序

    #include <stdio.h>
    #include <stdlib.h>
    
    #define keyType int 
    typedef struct
    {
    	keyType key;   //查找表中每个数据元素的值
    }ElemType;
    
    typedef struct 
    {
    	ElemType *elem;//存放查找表中元素的数组
    	int length;    //记录查找表中数据的总数量
    }SSTable;
    
    //创建查找表
    void Create(SSTable *st,int length)
    {
    	//(*st) = (SSTable *)malloc(sizeof(SSTable));
    	st->length = length;
    	st->elem = (ElemType *)malloc((length + 1)*sizeof(ElemType));
    	printf("输入表中的数据元素:\n");
    	//根据查找表中数据元素的总长度,在存储时,从数组下标为1的空间开始存储数据
    	for (int i = 1;i<=length;i++)
    	{
    		scanf("%d",&(st->elem[i].key));
    	}
    }
    
    int search_seq(SSTable *st,keyType key)
    {
    	st->elem[0].key = key;    //将关键字作为一个数据元素放到查找表的第一个位置,起监视哨的作用
    	int i = st->length;
    	//从查找表的最后一个数据元素依次遍历,一直遍历到数组下标为0
    	while(st->elem[i].key!=key)
    	{
    		i--;
    	}
    	//如果 i = 0,说明查找失败,反之,返回的是含有关键字key的数据元素在查找表中的位置
    	return i;
    }
    
    int main()
    {
    	SSTable st;
    	Create(&st,6);
    	printf("请输入要查找数据的关键字:\n");
    	int key;
    	scanf("%d",&key);
    
    	int location = search_seq(&st,key);
    	if(location == 0)
    	{
    		printf("查找失败\n");
    	}
    	else
    	{
    		printf("数据在查找表中的位置为:%d\n",location);
    	}
    	return 0;
    }
    

    得出结果:
    输入表中的数据元素:
    11 22 33 44 55 66
    请输入要查找数据的关键字:
    66

    展开全文
  • 本文实例讲述了基于JavaScript实现的顺序查找算法。分享给大家供大家参考,具体如下: 对于查找数据来说,最简单的方法就是从列表的第一个元素开始对列表元素逐个进行判断,直到找到了想要的结果。这个方法叫做顺序...
  • 一、顺序查找Sequential Search 二、算法分析 三、顺序查找:无序表查找代码 一、顺序查找Sequential Search 如果数据项保存在如列表这样的集合中,我们会称这些数据项具有线性或者顺序关系。 在python list中...

    目录

     

    一、顺序查找Sequential Search

    二、算法分析

    三、顺序查找:无序表查找代码


    一、顺序查找Sequential Search

    如果数据项保存在如列表这样的集合中,我们会称这些数据项具有线性或者顺序关系。

    在python list中,这些数据项的存储位置称为下标,这些下标都是有序的整数。通过下标,我们可以按照顺序来访问和查找数据项,这种技术称为“顺序查找”。

    要确定列表中是否存在需要查找的数据项。

    首先从列表的第一个数据项开始,按照下标增长的顺序,逐个对比数据项,如果到最后一个都未发现要查找的项,那么查找失败。

    顺序查找:无序表查找代码

    def sequentialSearch(alist, item):
        found = False
        pos = 0
    
        while pos < len(alist) and not found:
            if alist[pos] == item:
                found = True
            else:
                pos += 1
    
        return found

    二、算法分析

    要对查找算法进行分析,首先要确定其中的基本计算步骤。回顾前面的知识,基本计算步骤必须要足够简单,并且在算法中反复执行。在查找算法中,这种基本计算步骤就是进行数据项的比对(当前数据项是等于还是不等于查找数据项,比对的次数决定了算法复杂度)。

    在顺序查找算法中,为了保证是讨论的一般情形,需要嘉定列表中的数据项并没有按值排列顺序,而是随机放置在列表中的各个位置。

    换句话说,数据项在列表各处出现的概率是相等的。

    数据项是否在列表中,比对的次数是不一样的。如果数据项不在列表中,需要比对所有的数据项才能得知,比对的次数是n,如果数据项在列表中,需要比对的次数情况就比较复杂。最好的情况,第一次比对就找到,最坏的情况,要n次比对。

    数据项在列表中,比对的一般情形如何?

    因为数据项在列表中各个位置出现的概率是相等的,所以平均状态下,比对的次数是n/2。

    所以顺序查找的算法复杂度是O(n)

    这里我们假定列表中的数据项是无序的,那么如果数据项排了序,顺序查找算法的效率又如何呢?

    实际的做法是,当数据项存在时,比对过程与无序表完全相同。不同之处在于,如果数据项不存在,比对可以提前结束。

    如下图,查找数据项50,当看到54时,可以知道后面不可能存在50,可以提前退出查找。

     

    三、顺序查找:无序表查找代码

    def ordersequentialSearch(alist, item):
        found = False
        stop = False
        pos = 0
    
        while pos < len(alist) and not found and not stop:
            if alist[pos] == item:
                found = True
            else:
                if alist[pos] > item:
                    stop = True
                else:
                    pos += 1
        return found

    展开全文
  • 查找算法--顺序查找

    2018-06-23 10:13:52
    数据结构用C++的实现,蓝桥杯,ACM,算法基础,C++入门
  • 36 顺序查找算法及程序实现;顺序查找算法的处理过程 假定在数组d中有n个数据查找键已经存储在变量key中其处理过程是从数组d的第1个元素d(1)开始依次判断各元素的值是否与查找键key相等若某个数组元素d(i)的值等于key...
  • 上一篇博客讲了有关于查找的概念及顺序查找算法,这次我们再讲解一种新的静态查找算法,大家还记得什么是静态查找吗?相信大家应该记得,如果大家印象不太深刻,可以看一下上一篇博客:【数据结构周周练】025 查找...

    一、前言

    上一篇博客讲了有关于查找的概念及顺序查找算法,这次我们再讲解一种新的静态查找算法,大家还记得什么是静态查找吗?相信大家应该记得,如果大家印象不太深刻,可以看一下上一篇博客:【数据结构周周练】025 查找算法详解及顺序查找算法实现。简单说,静态查找就是只查找,不修改。上次我们说适合静态查找的有顺序查找和折半查找等,今天就给大家讲述一下折半查找。

    细心的小伙伴们发现了,我在讲顺序查找的博客中并没有讲到顺序查找的ASL,因为我要放在这篇博客中与折半查找做对比,这样,大家才能印象更加深刻。

    二、折半查找

    1、折半查找概念

    折半查找也称二分查找(Binary Search),它是一种效率较高的查找方法。但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。

    查找过程如下:

    首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;

    否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。

    重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

    再次强调:折半查找在提升查找效率的同时,也对数据的要求有所提高:1.必须采用顺序存储结构。2.必须按关键字大小有序排列

    2、示例及代码

    给定一组数据,数据内容如下:

    numData[] = { 12,31,45,57,60,71,87,92 };

    用户指定查询内容,判断该组数据中是否有用户指定数据。算法实现如下:

    #include<iostream>
    #include<malloc.h>
    
    using namespace std;
    
    int numData[] = { 12,31,45,57,60,71,87,92 };
    int length = sizeof(numData) / sizeof(int);
    
    int SequentialSearch(int numData[],int searchElem) {
    	for (int i = 0; i < length; i++)
    	{
    		if (numData[i] == searchElem)
    			return i;
    	}
    	return -1;
    }
    
    int BinarySearch(int numData[], int searchElem) {
    	int small = 0;
    	int large = length-1;
    	int middle;
    	if (searchElem > numData[large] || searchElem < numData[0])
    		return -1;
    	while (small <= large)
    	{
    		middle = (small + large) / 2;
    		if (searchElem == numData[middle])
    			return middle;
    		else if (searchElem > numData[middle])
    			small = middle + 1;
    		else
    			large = middle - 1;
    	}
    	return -1;
    
    }
    
    void main() {
    	int se;
    	cout << "Please input the data that you want to inquire : ";
    	cin >> se;
    	int k;
    	//k = SequentialSearch(numData, se);
    	k = BinarySearch(numData, se);
    	if (k == -1)
    		cout << "There is no data that you want to query in this array. " << endl;
    	else
    		cout << "The number of the data that you inquiring is : " << k << endl;
    }
    

    3、实现效果

    三、折半查找与顺序查找算法对比分析

    1、回顾ASL

    大家还记得什么是ASL 吗?对!ASL就是平均查找长度。公式定义如下:

    2、顺序查找ASL

    首先给大家讲的是顺序查找,顺序查找,我们从第一个元素开始找起,找到我们要找的元素停止,由于可能该元素在数据中的每一个位置,包括最后一个,所以,我们查询可能的次数为:1,2,3,……,n。每次查询的概率为 1 / n 。所以顺序查找的ASL为:

    3、折半查找ASL

    接下来给大家讲的是折半查找,我们从中间元素开始找起,如果该元素小于我们要查找的元素,则从右边开始查找,如果该元素大于我们要查找的元素,从左边开始查找,直到找到或者全部找完为止。

    折半查找过程中,按照其查找流程,会生成如下的判定树,由于该判定树每个结点的左右结点个数差1或0,所以该判定树一定为平衡二叉树。假设判定树有n个结点,则树的深度为k。k的取值如下:

    且有

    通过分析该判定树,我们可以知道,层次为1的结点有2^(1-1)个,层次为2的结点有2^(2-1)个,……,层次为k的结点有2^(k-1)个,所以,我们可以求得ASL的值为:

    当n的值较大(n > 50)时,可有下列近似结果:

    4、对比

    对比我们从两方面:一方面是查找速度,另一方面是对数据的要求。

    在查找速度方面,顺序查找自然是不及折半查找,我们代码中数组的长度比较小,没有太大差距,当数据量较大时,我们就能明显感觉到运行时间差距了。

    从另一方面来说,顺序查找对数据要求不高,无需数据按照某种方式排列,也无需指定存储格式,顺序存储可以,链式存储也可以。所以从应用范围来说,顺序查找算法自然会更好。

    下一篇博客,我们会给大家讲到另外一种查找方式,这种方式会吸收顺序查找和折半查找的优点。这篇博客就给大家分享到这里啦,有什么问题,大家可以给我留言哦!

    展开全文
  • 顺序查找算法及C语言实现

    千次阅读 2020-03-19 08:55:37
    通过前面对静态查找表的介绍,静态查找表即为只做查找操作的查找...静态查找表用顺序存储结构表示时,顺序查找的查找过程为:从表中的最后一个数据元素开始,逐个同记录的关键字做比较,如果匹配成功,则查找成功;...
  • 1、java顺序查找算法

    2019-09-27 15:06:46
    例如:程序随机生成一个20个整数数据的数组,然后输入要查找的数据,接着,可以采用简单的对比的方法进行查找,即顺序查找方法 public class RandomDemo { static int N = 20; public static void main(String ...
  • # -*- coding:utf8 -*- def seq_search(items, key): '''顺序查找''' for index, item in enumerate(items): if item == key: return index # 找到返回元素所处的下标 return -1 # 找不到返回-1 print(...
  • 算法针对无序数据,其基本的思想是:从数组的首元素开始,将数组的每个元素逐一与要查找的数据进行比较,直到找到相等的为止,如果查找结束都没有相等的元素,则查找不成功 2. 算法实现 时间复杂度:O(n) #include...
  • 顺序查找算法及程序实现;顺序查找;顺序查找的流程图;例题顺序查找;1首先在通用声明事件里定义数组d变量为全局变量 Dim d(1 To 10) As Integer Dim i, key As Integer 2程序一运行生成10个3位整数显示在标签1中 ...
  • 查找——线性表顺序查找算法

    千次阅读 2015-12-05 15:55:42
    *文件名称: 线性表顺序查找算法.cpp *作 者: 郑兆涵 *查找——线性表顺序查找算法 */ 问题:对线性表顺序查找算法进行分析 编程代码: //线性表顺序查找算法 #include #define MAXL 100 typedef int KeyTy
  • 1.顺序查找算法顺序查找算法比较简单,就是从数据序列中的第1个元素开始,从头到尾依次查找,直到查找到所要的数据或搜索完整个数据序列。顺序查找主要针对少量的,无规则的数据。2.java代码的顺序查找算法实现...
  • 查找算法顺序查找

    2020-06-30 16:41:15
    顺序查找又称为线性查找,查找过程为:从数组的第一个位置(或最后一个位置)开始,遍历整个数组,对下标索引对应的值与要查找的值进行比较,如果相等,则查找成功,返回下标值;如果遍历完整个数组,下标对应的值与...
  • 查找算法:二分查找、顺序查找的实现 参见博客:http://blog.csdn.net/xiaowei_cqu/article/details/7748260
  • 顺序查找算法实现(C++)

    千次阅读 2015-07-14 21:12:08
    顺序查找适用情况: 1、对静态查找表无任何要求 2、数据量较小时间复杂度:O(n)C++代码如下(可直接运行):#include #include using namespace std; void Sequential_Search(int *a, int n, int key) { int i = ...
  • 顺序查找和折半查找算法

    千次阅读 2019-10-30 15:48:34
    衡量查找算法的效率的一个指标 平均查找长度–对关键字比较次数的平均值 顺序查找 又称作线性查找,主要用于在线性表中进行查找。适用于对一般无序线性表的查找。 基本思想:从线性表的一端开始查找,逐个检查...
  • * 顺序查找的两种算法(带监视哨和没有带监视哨) * * @author chenjunxu * @since 2015-11-10 */ public class Main { public static void main(String[] args) { System.out.println("请输入一个数组的长
  • 查找算法思想 如果查找到相应的数据项,往往需要返回该数据项的地址或者位置信息。这样。程序中可以通过位置信息来显示数据项、插入数据项、删除数据项等操作。 如果没有查找到相应的数据项,则可以返回相应的提示...
  • 线性表的查找算法ASLASLASL的定义顺序查找基本思想及查找算法查找性能索引查找索引表的构建索引表的顺序查找算法查找性能 查找算法涉及两个主要问题:一是数据如何组织——查找表;而是在查找表上如何查找——查找...
  • 详细介绍了常见的4种查找算法,比如顺序查找/线性查找、二分查找/折半查找、插值查找、斐波那契查找等,并且提供了相应的Java代码实现。
  • 顺序查找算法

    2019-06-09 19:20:49
    顺序查找又叫线性查找,是最基本的查找技术,它的...顺序查找的实现算法如下: /* 顺序查找,a为数组,n为要查找的数组个数,key为要查找的关键字 */ int Sequential_Search(int *a, int n, int Key) { int i; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 268,702
精华内容 107,480
关键字:

顺序查找算法