长度为n的顺序表顺序查找时，当查找成功时候的平均查找长度为多少，不成功时又是多少？

Posted 2023-04-25

如题

若对大小为N的有序顺序表进行顺序查找，当查找不成功时，平均查找长度为 59)；当查找成功且表中仅有一个关键字等于欲查找的元素时，平均查找长度为 60 。

由于计算平均查找长度是以最坏可能性考虑,故从第一个节点开始比较到尾节点，需要比较n次，查找长度n；从第二个节点开始比较到尾节点,需要比较n-1次，查找长度n-1，最后一个节点比较1次,查找长度1，总长数＝n+(n-1)+...+2+1=n(n+1)/2。

查找不成功时平均查找长度＝(n(n+1)/2)* (1/(n+1))=n/2 ，具体算的过程类似查找成功时平均查找长度（ASL=(n+1)/2)。

扩展资料：

顺序表顺序将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构采用顺序存储结构的线性表。

顺序表的存储特点：只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L
　1≤i≤n 其中，L是元素占用存储单元的长度。

参考资料来源：百度百科-顺序表

参考技术A

有序表：成功：asl=（n+1）/2;

不成功：asl=n/2+n/(n+1);

无序表：成功：asl=(n+1)/2;

不成功：asl=n+1;

例如：

由于计算平均查找长度是以最坏可能性考虑，故从第一个节点开始比较到尾节点，需要比较n次，查找长度n；从第二个节点开始比较到尾节点,需要比较n-1次，查找长度n-1；最后一个节点比较1次,查找长度1。

总长数＝n+(n-1)+...+2+1=n(n+1)/2

查找不成功时平均查找长度＝(n(n+1)/2)* (1/(n+1))=n/2

扩展资料：

使用无序列表标签ul的type属性（使用CSS的list-style来代替）。用户可以指定出现在列表项前的项目符号的样式，其取值以及相应的符号样式如下：

（1）disc：指定项目符号为一个实心圆点（默认值是disc，是否使用该值在浏览器中效果都一样）；

（2）circle：指定项目符号为一个空心圆点；

（3）square：指定项目符号为一个实心方块；

（4）none：无项目符号。

参考资料来源：百度百科-无序列表

参考技术B 查找成功时，平均查找长度是 1 + 2 + ...+ n = n(n+ 1)/2,
查找失败时，查找长度为n + 1 因为查找到第n个不成功后还要再比较一次 参考技术C 有序表：成功：asl=（n+1）/2;
不成功：asl=n/2+n/(n+1);
无序表：成功：asl=(n+1)/2;
不成功：asl=n+1; 参考技术D 成功的平均查找长度是n(n+1)/2,失败是n+1

排序算法

查找，也可称检索，是在大量的数据元素中找到某个特定的数据元素而进行的工作。查找是一种操作。

 

顺序查找

针对无序序列的一种最简单的查找方式。

时间复杂度为O(n)。

查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = (1+2+3+…+n)/n = (n+1)/2 ;

当查找不成功时，需要n+1次比较，时间复杂度为O(n);

优点： 
算法简单，且对表的结构无任何要求，无论是用向量还是用链表来存放结点，也无论结点之间是否按关键字有序，它都同样适用。 

缺点： 
查找效率低，因此，当n较大时不宜采用顺序查找。 

 

//顺序查找
int SequenceSearch(int a[], int value, int n)
{
    int i;
    for(i=0; i<n; i++)
        if(a[i]==value)
            return i;
    return -1;
}

 

二分查找

说明：元素必须是有序的，如果是无序的则要先进行排序操作。

基本思想：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

复杂度分析： 最坏情况下，关键词比较次数为log 2 (n+1)，且 期望时间复杂度为O(log 2 n) ；

注： 折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要 频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。——《大话数据结构》

//二分查找（折半查找），迭代版
int BinarySearch1(int a[], int value, int n)
{
  int low, high, mid;
  low = 0;
  high = n-1;
  while(low<=high)
  {
    mid = (low+high)/2;
    if(a[mid]==value)
      return mid;
    if(a[mid]>value)
      high = mid-1;
    if(a[mid]<value)
      low = mid+1;
  }
  return -1;
}
//二分查找，递归版本
int BinarySearch2(int a[], int value, int low, int high)
{
  int mid = low+(high-low)/2;
  if(a[mid]==value)
    return mid;
  if(a[mid]>value)
    return BinarySearch2(a, value, low, mid-1);
  if(a[mid]<value)
    return BinarySearch2(a, value, mid+1, high);
}

 

插值查找（二分查找的改进）

在介绍插值查找之前，首先考虑一个新问题，为什么上述算法一定要是折半，而不是折四分之一或者折更多呢？

打个比方，在英文字典里面查“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(log 2 (log 2 n))。

//插值查找
int InsertionSearch(int a[], int value, int low, int high)
{
  int mid = low+(value-a[low])/(a[high]-a[low])*(high-low);
  if(a[mid]==value)
    return mid;
  if(a[mid]>value)
    return InsertionSearch(a, value, low, mid-1);
  if(a[mid]<value)
    return InsertionSearch(a, value, mid+1, high);
}

 

分块查找

分块查找是将顺序查找与折半查找相结合的一种查找方法。 

基本思想： 
1. 首先将查找表分成若干块，在每一块中数据元素的存放是任意的，但块与块之间必须是有序的（假设这种排序是按关键字值递增的，也就是说在第一块中任意一个数据元素的关键字都小于第二块中所有数据元素的关键字，第二块中任意一个数据元素的关键字都小于第三块中所有数据元素的关键字，依次类推）； 
2. 建立一个索引表，把每块中最大的关键字值按块的顺序存放在一个辅助数组中，这个索引表也按升序排列； 
3. 查找时先用给定的关键字值在索引表中查找，确定满足条件的数据元素存放在哪个块中，查找方法既可以是折半方法，也可以是顺序查找。 
4. 再到相应的块中顺序查找，便可以得到查找的结果。 

 

　　图 1-2 所示为一个索引顺序表。其中包括三个块，第一个块的起始地址为 0，块内最大关键字为 25；第二个块的起始地址为 5，块内最大关键字为 58；第三个块的起始地址为10，块内最大关键字为 88。

　　分块查找的基本过程如下：

　　（1）首先，将待查关键字 K 与索引表中的关键字进行比较，以确定待查记录所在的

块。具体的可用顺序查找法或折半查找法进行。

　　（2）进一步用顺序查找法，在相应块内查找关键字为 K的元素。

     / * 分块查找 
     * 
     * @param index 索引表，其中放的是各块的最大值 
     * @param st 顺序表， 
     * @param key 要查找的值 
     * @param m 顺序表中各块的长度相等，为m 
     * @return 
     */ 
int BlockSearch(int[ ] index, int[ ] st, int key, int m)   //分块查找
    { 
          //  在序列st数组中，用分块查找方法查找关键字为key的记录 
         // 1.在index[ ] 中折半查找，确定要查找的key属于哪个块中  
          int i = BinarySearch(index, key);             
          if(i >= 0) 
          { 
              int j = i > 0 ? i * m : i; 
              int len = (i + 1) * m; 
              // 在确定的块中用顺序查找方法查找key 
              for(int k = j; k < len; k++)  
              { 
                  if(key == st[k]) 
                  { 
                      System.out.println("查询成功"); 
                      return k; 
                  } 
              } 
           } 
          System.out.println("查找失败"); 
          return -1; 
    } 
    
    int BinarySearchs(int[] data, int tmpData) 
    { 
        int mid; 
        int low = 0; 
        int high = data.length - 1; 
        while(low <= high) 
        { 
            mid = (low + high) / 2;     // 中间位置 
            if(tmpData == data[mid]) 
            { 
                return mid;             
            } 
            else if(tmpData < data[mid])     
            { 
                high = mid - 1; 
            } 
            else 
            { 
                low = mid + 1; 
                return low; 
            } 
        } 
        return -1;                // 没有查找到 
  } 

 

斐波拉契查找

在介绍斐波拉契查找算法之前，我们先介绍一下很它紧密相连并且大家都熟知的一个概念——黄金分割。

　　在介绍斐波那契查找算法之前，我们先介绍一下很它紧密相连并且大家都熟知的一个概念——黄金分割。

　　黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比，其比值约为1:0.618或1.618:1。

　　0.618被公认为最具有审美意义的比例数字，这个数值的作用不仅仅体现在诸如绘画、雕塑、音乐、建筑等艺术领域，而且在管理、工程设计等方面也有着不可忽视的作用。因此被称为黄金分割。

　　大家记不记得斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….（从第三个数开始，后边每一个数都是前两个数的和）。然后我们会发现，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，利用这个特性，我们就可以将黄金比例运用到查找技术中。

 

　　基本思想： 也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算 法。

　　相对于折半查找，一般将待比较的key值与第mid=（low+high）/2位置的元素比较，比较结果分三种情况：

　　1）相等，mid位置的元素即为所求

　　2）>，low=mid+1;

　　3）<，high=mid-1。

斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1;

　　开始将key值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1),比较结果也分为三种

　　1）相等，mid位置的元素即为所求

　　2）>，low=mid+1,k-=2;

　　说明：low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))= F(k)-1-F(k-1)=F(k)-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找。

　　3）<，high=mid-1,k-=1。

　　说明：high=mid-1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归 的应用斐波那契查找。

 

　　复杂度分析： 最坏情况下，时间复杂度为O(log 2 n)，且其期望复杂度也为O(log 2 n)。

// 斐波那契查找.cpp 

#include "stdafx.h"
#include <memory>
#include  <iostream>
using namespace std;

const int max_size=20;//斐波那契数组的长度

/*构造一个斐波那契数组*/ 
void Fibonacci(int * F)
{
    F[0]=0;
    F[1]=1;
    for(int i=2;i<max_size;++i)
        F[i]=F[i-1]+F[i-2];
}

/*定义斐波那契查找法*/  
int FibonacciSearch(int *a, int n, int key)  //a为要查找的数组,n为要查找的数组长度,key为要查找的关键字
{
  int low=0;
  int high=n-1;
  
  int F[max_size];
  Fibonacci(F);//构造一个斐波那契数组F 

  int k=0;
  while(n>F[k]-1)//计算n位于斐波那契数列的位置
      ++k;

  int  * temp;//将数组a扩展到F[k]-1的长度
  temp=new int [F[k]-1];
  memcpy(temp,a,n*sizeof(int));

  for(int i=n;i<F[k]-1;++i)
     temp[i]=a[n-1];
  
  while(low<=high)
  {
    int mid=low+F[k-1]-1;
    if(key<temp[mid])
    {
      high=mid-1;
      k-=1;
    }
    else if(key>temp[mid])
    {
     low=mid+1;
     k-=2;
    }
    else
    {
       if(mid<n)
           return mid; //若相等则说明mid即为查找到的位置
       else
           return n-1; //若mid>=n则说明是扩展的数值,返回n-1
    }
  }  
  delete [] temp;
  return -1;
}