第二十五章 Caché 算法与数据结构 插值查找

第二十五章 Caché 算法与数据结构 插值查找

基本思想

基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。

算法复杂度

O(log2(log2n))

使用场景

对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

举例

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

• 打个比方，在英文字典里面查“apple”，你下意识翻开字典是翻前面的书页还是后面的书页呢？如果再让你查“zoo”，你又怎么查？很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。
• 同样的，比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5，我们自然会考虑从数组下标较小的开始查找。
• 经过以上分析，折半查找这种查找方式，不是自适应的（也就是说是傻瓜式的）。二分查找中查找点计算如下：

　　mid=(low+high)/2,即mid=low+1/2∗(high−low);mid=(low+high)/2, 即mid=low+1/2*(high-low);mid=(low+high)/2,即mid=low+1/2∗(high−low);

通过类比，我们可以将查找的点改进为如下：

　　mid=low+(value−a[low])/(a[high]−a[low])∗(high−low)，mid=low+(value-a[low])/(a[high]-a[low])*(high-low)，mid=low+(value−a[low])/(a[high]−a[low])∗(high−low)

• 也就是将上述的比例参数1/2改进为自适应的，根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

非递归

插值类

Class PHA.YX.Arithmetic.InsertSearch Extends %RegisteredObject
{

Method search(array As PHA.YX.Arithmetic.Array, value As %Integer)
{
	if (array.length() = 0){
		return -1
	}
	#dim low as %Integer = 0
	#dim high = array.length() - 1
	#dim mid as %Integer = -1
	while (low <= high){
		s mid =  (value - array.get(low)) \ (array.get(high) - array.get(low)) * (high - low)
		s mid = low + mid
		w "mid:" _ mid,!
		if (value > array.get(mid)){
			s low = mid + 1
		} elseif (value < array.get(mid)){
			s high = mid - 1
		}else{
			return mid
		}
	}
	return -1
}

}

调用

/// w ##class(PHA.YX.Arithmetic).InsertSearch(44)
ClassMethod InsertSearch(x)
{
	#dim array as PHA.YX.Arithmetic.Array = ##class(PHA.YX.Arithmetic.Array).%New()
	d array.init(10)
	d array.insert(0,11)
	d array.insert(1,22)
	d array.insert(2,33)
	d array.insert(3,44)
	d array.insert(4,55)
	d array.insert(5,66)
	d array.insert(6,77)
	d array.insert(7,88)
	d array.insert(8,99)
	d array.insert(9,111)
	#dim search as PHA.YX.Arithmetic.InsertSearch = ##class(PHA.YX.Arithmetic.InsertSearch).%New() 
	s index = search.search(array, x)
	w "------插值数列-----",!
	w index,!
	
	q ""
}

DHC-APP>w ##class(PHA.YX.Arithmetic).InsertSearch(44)
mid:0
mid:1
mid:2
mid:3
------插值数列-----
3
 

递归

插值类

Method recursive(array As PHA.YX.Arithmetic.Array, left As %Integer, right As %Integer, value As %Integer)
{
	if (left > right) ||(value > array.get(array.length() - 1)) ||(value < array.get(0)){
		ret -1
	}
	s mid =  (right - left) * (value - array.get(left)) \ (array.get(right) - array.get(left))
	s mid = left + mid
	w "mid recursive:" _ mid,!
	if (value > array.get(mid)){
		s mid = ..recursive(array, mid + 1, right , value)
	} elseif (value < array.get(mid)){
		s mid = ..recursive(array, left, mid , value)
	}else{
		return mid
	}
	q mid
}

调用

/// w ##class(PHA.YX.Arithmetic).InsertSearch(44)
ClassMethod InsertSearch(x)
{
	#dim array as PHA.YX.Arithmetic.Array = ##class(PHA.YX.Arithmetic.Array).%New()
	d array.init(10)
	d array.insert(0,11)
	d array.insert(1,22)
	d array.insert(2,33)
	d array.insert(3,44)
	d array.insert(4,55)
	d array.insert(5,66)
	d array.insert(6,77)
	d array.insert(7,88)
	d array.insert(8,99)
	d array.insert(9,111)
	#dim search as PHA.YX.Arithmetic.InsertSearch = ##class(PHA.YX.Arithmetic.InsertSearch).%New() 
	s index = search.search(array, x)
	w "------插值数列-----",!
	w index,!
	
	
	s index = search.recursive(array, 0, array.length() - 1,x)
	w "------递归插值数列-----",!
	w index,!
	
	q ""
}

DHC-APP>w ##class(PHA.YX.Arithmetic).InsertSearch(44)
mid:0
mid:1
mid:2
mid:3
------插值数列-----
3
mid recursive:2
mid recursive:3
------递归插值数列-----
3