精华内容
下载资源
问答
  • 神话丿小王子的百度文库 Java 中常用的查找算法顺序查找和查找 1顺序查找 a) 原理顺序查找就是按顺序从头到尾依次往下查找找到数据则提前结束查找 找不到便一直查找下去直到数据最后一位 b) 图例说明 原始数据...
  • 主要介绍了php顺序查找和查找示例,需要的朋友可以参考下
  • 查找算法:二查找、顺序查找的实现 参见博客:http://blog.csdn.net/xiaowei_cqu/article/details/7748260
  • 顺序查找和查找

    千次阅读 2018-12-05 20:14:47
    顺序查找(算法思想): 从待查找数据的第一个元素开始,逐个将每个元素与要查找的数据值进行对比:如果比较到两者值相同,则查找成功,如果一直未找到,则查找失败 def Linear(values, key): leng = len(values) ...

    顺序查找(算法思想):
    从待查找数据的第一个元素开始,逐个将每个元素与要查找的数据值进行对比:如果比较到两者值相同,则查找成功,如果一直未找到,则查找失败

    def Linear(values, key):
        leng = len(values)
        for i in range(leng):
            if values[i] == key:
                return "查找成功:%d" % i
        else:
            return "查找失败"
    
    values = [8, 9, 6, 5, 7, 2, 3, 1, 4, 10, 13, 12, 11]
    print(Linear(values, 7))
    

    二分查找(算法思想):
    找出“有序数据”中的中间元素,有中间元素值将原数据分成两个子表,然后根据指定查找值与中间元素的大小关系进行对比:若相对
    则查找成功,若大于则在右边进行查找,若小于则在左边进行查找

    # 递归法
    def twofen_sort(values, key , left, right):
        if left > right:
            return -1
        middle = (left + right) // 2
        if key == values[middle]:
            return 1
        else:
            if key > values[left]:
                left = middle +1
                return twofen_sort(values, key, left, right)
            else:
                right = middle -1
                return twofen_sort(values, key, left, right)
    
    values = [8, 9, 6, 5, 7, 2, 3, 1, 4, 10, 13, 12, 11]
    values.sort()  # 进行排序
    leng = len(values)
    result = twofen_sort(values, 7, 0, leng - 1)
    if result == 1:
        print("查找成功")
    else:
        print("查找失败")
    
    # 循环法
    def binary(values, key):
        left = 0
        right = len(values) - 1
        while left <= right:
            middle = (left + right) // 2
            if values[middle] == key:
                # 成功找到返回下标
                return middle
            elif values[middle] > key:
                # 在左侧查找
                right = middle - 1
            else:
                # 在右侧查找
                left = middle + 1
        return -1
    
    
    values = [2, 4, 8, 9, 41, 54, 84, 98]
    result = binary(values, 54)
    if result == -1:
        print("查找失败")
    else:
        print("查找成功:", result)
    
    展开全文
  • 编写程序数据序列采用二查找法和顺序查找法查找元素的下标,要求使用类模板实现(其中二分法查找算法要求用递归实现,给定数据序列有序)。
  • 迭代顺序查找、递归顺序查找、二查找之间的对比
  • 查找表按照操作方式来有两大种:静态查找表动态查找表。 动态查找表:在查找过程中同时插入查找表中不存在的数据元素,或者从查找表中删除已经存在的某个数据元素。 1. 顺序查找 /* 顺序查找,a为数组,n...

    查找定义 :根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录)。
    查找表分类:静态查找表和动态查找表。
    动态查找表:在查找过程中同时插入查找表中不存在的数据元素,或者从查找表中删除已经存在的某个数据元素。

    1. 顺序查找

    /* 顺序查找,a为数组,n为要查找的数组元素个数,key为要查找的关键字*/
    int Sequential_Search(int *a, int n, int key)
    {
         int i = 0;
         for(; i < n; i++)
         {
              if(a[i] == key)
                   return i;
         }
         return 0;
    }
    
    /*有哨兵顺序查找-优化最简单的顺序查找*/
    /*优化部分:a[0]存放要查找的关键字key,减少了数组越界的比较,如果查找表长度很大,还是比最简单的顺序查找快很多的。ps:a[0] = key的目的就是让上述的简单顺序查找的两次判断修正为一次a[i]与a[0]是否相等的一次判断。*/
    int Sequential_Search2(int *a, int n, int key)
    {
         int i;
         a[0] = key;
         for(i = n; a[i] != a[0]; i--);
         return i;
    }
      平均查找长度 (Average Search Length,ASL)
         需和指定key进行比较的关键字的个数的期望值,成为查找算法在查找成功时的平均查找长度。
         对于含有n个数据元素的查找表,查找成功的平均查找长度为:ASL = Pi*Ci的和。
         Pi:查找表中第i个数据元素的概率。
         Ci:找到第i个数据元素时已经比较过的次数。
         顺序查找 查找 成功 时的平均查找长度为:
         (假设每个数据元素的概率相等) ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;
         当查找 不成功 时,需要n+1次比较,时间复杂度为O(n);


    2. 有序表查找


    2.1 折半查找

    前提:线性表中的记录必须是关键字有序(通常从小到大),线性表必须采用 顺序存储。
    基本思想:取中间记录作为比较对象,若给定值与中间记录的关键字相等,则查找成功;若给定值小于中间记录的关键字,则在中间记录左半区继续查找;否则,在右半区查找。不断重复,知道查找成功或者查找失败为止。
    /*折半查找,非递归*/
    int Binary_Search(int *a, int n, int key)
    {
         int low, high;
         int mid;
         low = 1;
         high = n;
        
         while(low < high)			//可以有等号 low < = high ,不影响判断。
         {
              mid = (low + high) / 2; 	//可以修正为 mid = (low + high) >> 1;
              if(a[mid] == key)
                   return mid;
              if(a[mid] > key)
                   high = mid - 1;
              if(a[mid] < key)
                   low = mid + 1;		//对于if else语句,可以考虑条件表达式,减少代码的行数。
         }
         return 0;
    }
    /*折半查找,递归实现*/
    int Binary_Search2(int *a, int low, int high, int key)
    {
         int mid = (low + high) / 2;
         if(a[mid] == key)
              return mid;
         if(a[mid] > key)
              return Binary_Search2(a, low, mid-1, key);     //有没有return都可以。
         else
              return Binary_Search2(a, mid+1, high, key);     //有没有return都可以。
    }
    /*      ASL: “具有n个节点的完全二叉树的深入为[log2n]+1,尽管折半查找判定二叉树不是完全二叉树,但同样相同的推导可以得出,
                   最坏情况是查找到关键字或查找失败的次数为[log2n]+1”,最好情况是1,所以折半查找的时间复杂度为o(logN)>o(n).

         注:折半查找的前提条件是需要有序表顺序存储,对于静态查找表,一次排序后不再变化,这样的算法已经比较好了。但对于需要
         频繁执行插入或删除操作的数据集来说,维护有序的排序会带来不小的工作量,那就不建议使用。——《大话数据结构》
    */

    2.2 插值查找

    首先考虑一个新问题,为什么一定要是折半,而不是折四分之一或者折更多呢?
    打个比方,在英文字典里面查“apple”,你下意识翻开字典是翻前面的书页还是后面的书页呢?如果再让你查“zoo”,你又怎么查?很显然,这里你绝对不会是从中间开始查起,而是有一定目的的往前或往后翻。
    同样的,比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5, 我们自然会考虑从数组下标较小的开始查找。
    经过以上分析,折半查找这种查找方式,还是有改进空间的,并不一定是折半的!
    mid = (low+high)/ 2, 即 mid = low + 1/2 * (high - low);
    改进为下面的计算机方案(不知道具体过程):mid = low + (key - a[low]) / (a[high] - a[low]) * (high - low),也就是将上述的比例参数1/2改进了,根据关键字在整个有序表中所处的位置,让mid值的变化更靠近关键字key,这样也就间接地减少了比较次数。

    分析:从时间复杂度上来看,它也是o(n),但是对于表长较大,而关键字分布又比较均匀的查找表来说,插值查找算法的平均性能比折半查找要好的多。反之,数组中如果分布非常不均匀,那么差值查找未必是很合适的选择。

    2.3 斐波那契查找

    原理:利用斐波那契数列的性质,黄金分割的原理来确定mid的位置。
    代码如下:
    /*斐波那契 查找*/
    int Fbonacci_Search(int *a, int n, int key)
    {
    	int low,high,mid,i,k;
    	int F[] = {0,1,1,2,3,5,8,13,21,34};		//经典的斐波那契数列已经早就定义好,也可以递归自己求解。
    	low = 1;
    	high = n;
    	k = 0;
    	while(n > F[k] - 1)	//计算 n 位于斐波那契数列的位置
    		k++;
    	for(i=n; i<F[k] - 1; i++)	//将不满的数值补全
    		a[i] = a[n];
    	while(low <= high)
    	{
    		mid = low + F[k-1] - 1;			//利用斐波那契数列来找寻下一个要比较的关键字的位置
    		if(key < a[mid])
    		{
    			high = mid - 1;
    			k--;
    		}
    		else 
    		{
    			if(key > a[mid])
    			{
    				low = mid + 1;
    				k = k -2;
    			}
    			else
    			{
    				if(mid <= n)
    					return mid;
    				else
    					return n;
    			}
    		}
    	}
    }

    总结:
    折半查找进行加法与除法运算(mid = (low + high) / 2),插值查找进行复杂的四则运算( mid = low + (key - a[low] / (a[high] - a[low]) * (high - low)) ),二斐波那契查找只是运用简单家减法运算 (mid  = low + f[k-1] -1) ,在海量的数据查找过程中,这种席位的差别会影响最终的查找效率。三种有序表的查找本质上是分割点的选择不同,各有优劣,实际开发可根据数据的特点综合考虑再做决定。

    展开全文
  • 顺序查找和查找 一、顺序查找思想  1、 从表的一端开始扫描,顺序扫描线性表,依次扫描到的结点关键字与给定的值K相比较.如果当前扫描到的结点的关键字与给定的值K相等,则查找成功;若扫描结束后,仍未找到关键字...

                                                                          顺序查找和二分查找

    一、顺序查找思想

           1、 从表的一端开始扫描,顺序扫描线性表,依次扫描到的结点关键字与给定的值K相比较.如果当前扫描到的结点的关键字与给定的值K相等,则查找成功;若扫描结束后,仍未找到关键字与给定的值K相等,则查找失败;

         2、顺序查找既适用于顺序存储结构,也适用于线性表的链式存储结构;

         3、ASL= (n+1)/2为其平均查找长度

         4、优点:算法简单,对存储结构形式没有要求 缺点:浪费空间,当长度非常大时效率低

         5、算法描述:

    /**
    *顺序查找
    *@param int a[] 表示查找的库
    *@param int length 表示数组a的长度
    *@param int key 表示需要查找的目标对象
    *@return  int
    */
    int orderSerch(int a[],int length,int key){
    	int count = 0;
    	if(key >a[length-1]){
    	      cout<<"您输入的元素不存在!"<<endl;
    	}
    	for(int i = 0; i< length ;){
    		if(key >a[i] ){
    			count++;
    		    i++;    
    		}else if(key == a[i]){
    			cout<<"顺利查到了,查找成功!"<<endl;
    			cout<<"查找次数:"<<count<<endl;
    			recode[0] = count;
    		    return i;
    		}else{
    			cout<<"没有查找到,查找失败!"<<endl;
    			cout<<"查找次数:"<<count<<endl;
    			return -1;
    		}
    	}
    }
    二、二分查找基本思想

             二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

                   折半查找法也称为二分查找法,它充分利用了元素间的次序关系,采用分治策略,可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是,将n个元素分成个数大致相同的两半,取a[n/2]与欲查找的x作比较,如果x=a[n/2]则找到x,算法终止。如 果x<a[n/2],则我们只要在数组a的左半部继续搜索x(这里假设数组元素呈升序排列)。如果x>a[n/2],则我们只要在数组a的右 半部继续搜索x。这些都是从百度文库copy过来的只是便于理解,由于此算法太简单了,这里就不多说了。

    贴上代码:

    /**
    *二分查找
    *@param int a[] 表示查找的库
    *@param int length 表示数组a的长度
    *@param int key 表示需要查找的目标对象
    *@return  int
    */
    int BinarySerch(int a[],int length ,int key){
    	     int count = 0;
    	     if(key >a[length-1]){
    	           cout<<"您输入的元素不存在!"<<endl;
    			   return -1;
    	     }
             int low = 0,high = length-1;//low 和high表示的是顺序表的低位和高位,分别指向顺序表的第一个位置和最后一个位置
    		 int mid = 0;//用来记录中间值的
    		 while(low <= high ){
    			  count++;
    		      mid = (low + high )/2;
    			  if(a[mid] == key){
    				    cout<<"查找次数:"<<count<<endl;
    					recode[1] = count;
    			        cout<<"查找成功!"<<endl;
    					return 1;
    			  }
    			  if(a[mid] < key ){
    			        low = mid+1;
    			  }
    			  if(a[mid] > key ){
    			         high = mid-1;
    			  }
    		 }
    		 if(high == mid&& a[mid] != key ){
    			   cout<<"查找次数:"<<count<<endl;
    		       cout<<"查找失败!"<<endl;
    			   return -1;
    		 }
    }
    贴上全部代码:这里我把顺序查找和二分查找弄在了一起,很便于观察和学习,而且使用快排来进行排序,对于向我这样的初学者是一个完整的可学习的代码。

    #include<iostream>
    #include<stdlib.h>
    #include<windows.h>
    using namespace std;
    int recode[2]={0};
    //快速排序以递归实现的代码
    void QKSort(int a[],int low,int high)
    {
        if(low>=high)
        {
              return;
        }
        int i = low;
        int j = high;
        int  key = a[low];
    	while(i != j){
    		for(;j != i;j--){
    			if(a[j] <= key ){
    			     a[i] = a[j];
    				 break;
    			}
    		}
    		for(;i != j;i++){
    			if(a[i] > key){
    			     a[j] = a[i];
    				 break;
    			
    			}
    		}
    	} 
    
    
        a[i]=key;
        QKSort(a,low,i-1);
        QKSort(a,j+1,high);
    }
    /**
    *顺序查找
    *@param int a[] 表示查找的库
    *@param int length 表示数组a的长度
    *@param int key 表示需要查找的目标对象
    *@return  int
    */
    int orderSerch(int a[],int length,int key){
    	int count = 0;
    	if(key >a[length-1]){
    	      cout<<"您输入的元素不存在!"<<endl;
    	}
    	for(int i = 0; i< length ;){
    		if(key >a[i] ){
    			count++;
    		    i++;    
    		}else if(key == a[i]){
    			cout<<"顺利查到了,查找成功!"<<endl;
    			cout<<"查找次数:"<<count<<endl;
    			recode[0] = count;
    		    return i;
    		}else{
    			cout<<"没有查找到,查找失败!"<<endl;
    			cout<<"查找次数:"<<count<<endl;
    			return -1;
    		}
    	}
    }
    /**
    *二分查找
    *@param int a[] 表示查找的库
    *@param int length 表示数组a的长度
    *@param int key 表示需要查找的目标对象
    *@return  int
    */
    int BinarySerch(int a[],int length ,int key){
    	     int count = 0;
    	     if(key >a[length-1]){
    	           cout<<"您输入的元素不存在!"<<endl;
    			   return -1;
    	     }
             int low = 0,high = length-1;//low 和high表示的是顺序表的低位和高位,分别指向顺序表的第一个位置和最后一个位置
    		 int mid = 0;//用来记录中间值的
    		 while(low <= high ){
    			  count++;
    		      mid = (low + high )/2;
    			  if(a[mid] == key){
    				    cout<<"查找次数:"<<count<<endl;
    					recode[1] = count;
    			        cout<<"查找成功!"<<endl;
    					return 1;
    			  }
    			  if(a[mid] < key ){
    			        low = mid+1;
    			  }
    			  if(a[mid] > key ){
    			         high = mid-1;
    			  }
    		 }
    		 if(high == mid&& a[mid] != key ){
    			   cout<<"查找次数:"<<count<<endl;
    		       cout<<"查找失败!"<<endl;
    			   return -1;
    		 }
    }
    //菜单
    void menu(){
            cout<<"               |----------------------------------------------------|"<<endl;
    		cout<<"               |----------1、二分查找                ---------------|"<<endl;
    		cout<<"               |----------2、顺序查找                ---------------|"<<endl;
    		cout<<"               |----------3、查找次数比较            ---------------|"<<endl;
    		cout<<"               |----------------------------------------------------|"<<endl;
    
    
    }
    int count1=0;
    void operation(int a[],int length){
    	  menu();
    	  count1++;
    	  int key= 0;
    	  cout<<"请选择需要的服务:"<<endl;
    	  int input = 0;
    	  cin >>input;
    	  if(input <0||input >3){
    	       cout<<"请重新选择:"<<endl;
    		   operation(a,length);
    	  }
    	  char c=0;
    	  cout<<"-----"<<count1<<endl;
    	  if(count1 >4){
    	        system("CLS");
    			operation(a,length);
    			count1= 0;
    	  }
    	  switch(input){
    	  case 1:cout<<"进行的是二分查找---"<<endl;cout<<"请输入需查找的元素:";cin>>key;BinarySerch(a,length,key);cout<<"请选择是否继续操作:Y/N"<<endl;cin>>c;
    		  if(c =='Y'||c=='y'){operation(a,length);}else if(c=='N'||c=='n'){return ;}else{cout<<"输入选择有误!"<<endl;}
    	  case 2:cout<<"进行的是顺序查找---"<<endl;cout<<"请输入需查找的元素:";cin>>key;orderSerch(a,length,key);cout<<"请选择是否继续操作:Y/N"<<endl;cin>>c;
    		  if(c =='Y'||c=='y'){operation(a,length);}else if(c=='N'||c=='n'){return ;}else{cout<<"输入选择有误!"<<endl;}
    	  case 3:cout<<"查找查找次数:"<<endl;cout<<"二分查找查找次数:"<<recode[1]<<endl;cout<<"顺序查找查找次数:"<<recode[0]<<endl;
    		  cout<<"请选择是否继续操作:Y/N"<<endl;cin>>c;
    		  if(c =='Y'||c=='y'){operation(a,length);}else if(c=='N'||c=='n'){return ;}else{cout<<"输入选择有误!"<<endl;operation(a,length);}
    	  
    	  }
    
    
    }
    int main()
    {
          int a[33]={2,4,5,1,7,8,0,9,10,11,12,13,14,15,16,17,19,18,6,55,33,44,32,78,76,65,46,99,33,66,77,67,43};
          QKSort(a,0,32);
    	  cout<<"库元素:"<<endl;
          for(int i=0;i<33;i++)
          {
                 cout<<a[i]<<"  ";
          }
    	  cout<<endl;
    	  operation(a,33);
          system("PAUSE");
          return 0;
    }
    
    代码经验证过!

    展开全文
  • 【算法分析】查找算法:二查找、顺序查找

    万次阅读 多人点赞 2012-07-19 09:51:07
    此系列是四年专业课程学习的回顾,索引参见:http://blog.csdn.net/xiaowei_cqu/article/details/7747205 查找算法 查找算法是在存在的序列(list) 中查找特定的目标(target),要求序列中每个记录必须与一...

    08年9月入学,12年7月毕业,结束了我在软件学院愉快丰富的大学生活。此系列是对四年专业课程学习的回顾,索引参见:http://blog.csdn.net/xiaowei_cqu/article/details/7747205


    查找算法


    查找算法是在存在的序列(list) 中查找特定的目标(target),要求序列中每个记录必须与一个关键词(key)关联才能进行查找。

     
    查找算法通常需要两个输入:
    1、被查找的序列
    2、要查找的关键词
    查找算法的输出参数和返回值:
    1、返回类型为 Error_code 的值用以表示是否查找成功
    2、如果查找成功,返回 success, 输出参数 position 定位到目标所在位置
    3、如果查找失败,返回 not present,输出参数可能是未定义或不同于已有位置的任何值

    顺序查找算法


    顺序查找算法的思路很简单:从表的第一个元素开始一个一个向下查找,如果有和目标一致的元素,查找成功;如果到最后一个元素仍没有目标元素,则查找失败。

    【实验说明】

    题目:编写一个程序,对顺序表{3,6,2,10,1,8,5,7,4,9},采用顺序查找关键字5的过程。要求输出:
    1)原顺序表;2)查找到关键字的位置;3)进行比较的次数。
    1.首先要编写类表List。需要满足最基本的操作插入insert(),获取retrieve(),以及得到大小size()。
    2.我们观察题目要求,表中虽然存储的是简单的整数,但如果我们使用List<int>对象显然无法记录比较次数,所以我们自己写一个类Key通过其内部int类型的数据成员来记录存于表中的值,并模仿int基本的逻辑操作,即编写重载逻辑运算符,同时增加一个静态数据成员comparisons用于记录其比较操作的次数。
    3.准备工作做好之后开始编写顺序查找算法。算法的思路很简单,也较易实现,从表中第一个元素开始比较,发现目标则返回元素所在表中位置;若遍历之后没有目标,则查找失败,返回-1表示表中没有目标元素。
    4.按题目要求编写最后的输出函数。

    【相关代码】

    函数 sequential_search
    int sequential_search(const List<int> &the_list,
    					  const Key &target)
    /*Post: If an entry in the_list is equal to target, then return the position
            of this entry. 
    		Otherwise return -1 
    */
    {
    	int position;
    	int s=the_list.size();
    	for(position=0;position<s;position++){
    		int data;
    		the_list.retrieve(position,data);
    		if(data==target){
    			return position;
    		}
    	}
    	return -1;
    }
    

    二分查找算法


    二分查找前提是表是按递增或递减顺序的规范表。此次实验中我们使用的是递增表。
    二分查找从表中间开始查找目标元素。如果找到一致元素,则查找成功。如果中间元素比目标元素小,则仍用二分查找方法查找表的后半部分(表是递增排列的),反之中间元素比目标元素大,则查找表的前半部分。

    【实验说明】

    题目:编写一个程序,对有序表{1,2,3,4,5,6,7,8,9,10},采用二分查找关键字9的过程。要求输出:
    1)原顺序表;2)查找到关键字的位置;3)进行比较的次数。
    1.二分查找算法的前提是表必须是有序的,如题目中是递增方式排列的表。实现表的有序一方面是用户规范输入,另一方面我们也可以编写有序的类来方便用户的输入。
    所以从List中派生类Oredered_list,重新编写函数Error_code insert(int position,const Record &data),使插入的位置不满足表的有序条件时,不能插入。
    同时编写插入的重载函数 Error_code insert(const Record &data),可以直接插入到合适的位置,方便用户输入。
    2.仍使用题目1中的Key来表示目标
    3.实现二分查找算法。通过书中的学习,我们直接使用添加相等判断的二分查找算法。即每次从表的中间元素开始比较,如果得到目标则返回元素所在表中位置;如果中间元素小于目标元素,则对右半部分继续二分查找;反之对前半部分表进行二分查找。若最后都没有目标元素,返回-1用以表示表中没有目标元素。
    4.仍使用题目1编写的输出函数将结果输出。
    /*注意这里因为Ordered_list是从List中派生而来,所以虽然print_out函数中第一个参数类型是List<int>,仍可以使用,而不用编写重载函数*/

    【相关代码】

    函数 binary_search
    int binary_search(const Ordered_list<int> &the_list,
    					const Key &target)
    /*Post: If an entry in the_list is equal to target, then return the position
            of this entry. 
    		Otherwise return -1 
    */
    {
    	int position;
    	int data;
    	int bottom=0,top=the_list.size()-1;
    	while(bottom<=top){
    		position=(bottom+top)>>1; 
    		the_list.retrieve(position,data);
    		if(data==target)
    			return position;
    		if(data<target)bottom=position+1;
    		else top=position-1;
    	}
    	return -1;
    }

    【过程记录】

    实验截图:


    【结果分析】


    A.实现顺序查找算法

    1.顺序查找算法思路很简单,就是一种遍历的思想,一个个查找目标元素,实现也很简单。
    2.对于有n个元素的表适用顺序查找。比较次数:不成功:比较n次。成功查找:最好的情况为1次,即第一个元素即为目标元素;最差的情况为n次;平均比较次数(n+1)/2次。
    所以当表很大时,顺序查找的代价是很大的。
    3.顺序查找算法不会有重复的比较出现,即一旦找到即成功,但同时这种代价是当表中有重复的目标元素时(比如有多个目标元素)我们只能得到第一个元素的位置。

    B.实现二分查找算法

    1.二分查找法思路:递增排列的表,首先从中间元素开始查找,如果元素比目标元素小,则查找后半部分表,反之查找前半部分表,并重复这一过程。这样每次查找中我们都把表的长度减半。
    2.二分查找在实现中有量bottom和top,每次减半的过程体现在bottom和top的改变上,在代码的实现上可以使用单纯的循环或者用函数递归的思想。
    递归思想更容易理解,但编写之后我们发现函数是尾递归,尾递归通常可以用简单的循环实现,循环在操作来说没有了函数调用的过程,更节省时间和空间。
    3.编码中小小地方的改动可能对程序有很大的改观。
    如上述两种二分查找binary_search_1(不比较等于的情况)binary_search_2(添加等于情况)



    实验代码下载:http://download.csdn.net/detail/xiaowei_cqu/4437702

    (转载请注明作者和出处:http://blog.csdn.net/xiaowei_cqu 未经允许请勿用于商业用途)



    展开全文
  • 项目背景: 从一个文件获取10万笔字符串类型数据,数据库表中查询出符合条件的5... *如果源数据是无序的,则顺序查找法效率高 原因: 1、字符串排序非常耗时 2、二查找法需要先排序 执行结果 ------------...
  • 顺序查找和折半查找

    千次阅读 2016-06-08 11:31:22
    /**************************************************** ... 实现顺序查找和折半查找, 两种查找方法作比较 [实验提示] 1. 编写顺序查找和折半查找算法 2. 修改算法把查找过程中所作比较及其结果 打印出来
  • 查找算法之顺序查找和查找

    千次阅读 2020-05-24 23:30:24
    1.顺序查找 代码如下: #include<cstdio> #include<iostream> using namespace std; const int maxn = 110; int arr[maxn]; int SequenceSearch(int arr[],int key, int n); int main(){ int n,key...
  • c语言 顺序查找与二查找

    千次阅读 2018-06-25 15:32:05
    查找必须是有顺序的序列(序列从大到小或从小到大)二查找思想:一段有序...如图找24顺序查找与二查找比较运行时间代码#include&lt;stdio.h&gt;#include&lt;time.h&gt;//clock函数头文件#in...
  • 静态表查找:顺序查找,二查找,斐波那契查找 运行环境:VS2010 */ #include #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 50 typedef ...
  • 静态查找:顺序查找和折半查找法

    千次阅读 2017-06-09 15:18:18
     顺序查找过程中往往设置监视哨,在查找过程中不用每一步都检查整个表是否查找完毕。  假设,每个元素的查找概率相同,顺序查找成功时平均查找长度为:(n+1)/2;顺序查找不成功时平均查找长度为:(n+1)/4。  ...
  • php数组的顺序查找和查找

    千次阅读 2016-09-16 22:00:52
    当我们用到数组的时候,通常会用到通过键来查找值,这种比较简单,直接可以...顺序查找:数组可以是无序的,也可以是有序的,因为顺序查找是通过便利整个数组来确定键值。在php中可以通过foreach来进行遍历。在这里定
  • 我们抛开二分查找算法,如果有这样的一个需求,需要在一些数字中找出有没有某个数字,我们应该怎么做?  1 首先我们会想到用什么数据结构存放这些数?  数据结构就是计算机存储组织、组织数据的方式。可以这样...
  • 顺序查找查找 分块查找 查找的定义是:给定一个值K,在含有n个结点的表中找出关键字等于给定值K的结点。若找到,则查找成功,返回该结点的信息或该结点在表中的位置;否则查找失败,返回相关的指示信息。1、...
  • 顺序查找查找法

    千次阅读 2019-05-27 10:39:10
    顺序查找法 方法1 def shunxu(f_list,temp): for index,i in enumerate(f_list): if i==temp: return index return None 方法2 def shunxu(f_flist,temp): for i in range(len(f_f...
  • 1、查找的定义 ...本文主要来介绍最基本的静态查找的方法:顺序查找和查找。 2、具体的实现 2.1 基本数据结构 /* 定义查找相关数据结构 */ #define TABLE_LENGTH 10 typedef int ElementTy
  • 1、基本概念 a. 从大量以前存储的数据中检索特定的一段信息或几段信息的操作称为查找或搜索。 b. 平均查找长度ASL的计算公式为: ...其中,n 为查找表的长度(元素个数),pi... 顺序表:是指采用数组集合或线性表进
  • 近期总结了各大排序算法的原理 ,并其进行了实现,想着一并把查找算法总结了,今天就着手开始总结查找算法。 废话不多说,这篇文章从最简单的查找算法开始讲起,之后会补充复杂的二叉搜索树查找(BST)B树,B+树...
  • Round17—顺序查找、二查找

    千次阅读 2019-11-09 16:37:15
    知道什么是顺序查找,什么是二查找,知道判定树,知道二查找的最大比较次数是 单选题: 2-1已知一个长度为16的顺序表L,其元素按关键字有序排列。若采用二查找法查找一个L中不存在的元素,则关键字的比较...
  • 顺序查找

    千次阅读 2018-10-13 23:48:24
    顺序查找通常分为对一般无序线性表的查找和对按关键字有序的顺序表的查找。 顺序查找的缺点是当n很大时,平均查找长度较大,效率低;优点是对数据元素的存储没有要求,顺序存储和链式存储皆可。 一般线性表的顺序...
  • 顺序查找通常分为对一般的无序线性表的顺序查找和对按关键字有序的顺序表的顺序查找。下面分别进行讨论。 1.1、一般线性表的顺序查找 作为一种最直观的查找方法,其基本思想是从线性表的一端开始,逐个检查关键字...
  • 静态查找(顺序查找和折半查找)

    千次阅读 2017-10-21 15:12:54
    听说过一句话,编程之久,除了数据结构算法什么也不属于我们。为了更好的学习数据结构...顺序查找: 算法描述 #include #include //顺序表的查找 #define EQ(a, b) ((a) == (b)) #define ElemType i
  • C语言实现数组二查找与顺序查找

    千次阅读 2010-08-21 12:52:00
    C语言实现数组中的值进行查找,算法实现:二查找与顺序查找

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 758,533
精华内容 303,413
关键字:

对分查找和顺序查找