查找

1. 线性搜索

简单线性查找伪代码：

linearSearch()
    for i = 0 ... n-1
    if A[i] 与key相等
        return i
    return not_found 

含有标记的线性查找

// 相比以上的代码，减少了比较次数，无须判断i<n
linearSearch()
    i = 0
    A[n] = key
    while A[i] 和key不同
        i++
    if i到达了n
        return not_found
    return i

　　

2. 二分搜索

 要求数据集合先进行排序。

伪代码：

binarySearch(A, key)
    left = 0
    right = n
    while left < right
        mid = (left + right) / 2
        if A[mid] == key
            return mid
        else if key < A[mid]
            right = mid
        else
            left = mid + 1
    return not_found

　　

3. 散列法

 散列法可根据各元素的值来确定元素的存储位置，再将位置保管在散列表中，从而实现高速搜索。其由容纳m个元素的数组T， 以及根据数据关键字决定数组下标的函数共同组成。

简单实现：

insert(data)
    T[h(data.key)] = data

search(data)
    return T[h(data.key)]

 散列函数，如 h(k) = k mod m

若只采用一个散列函数，可能会发生不同的key对应同一散列值，就会导致冲突，为解决冲突，可采用开放地址法，如双散列结构，一旦出现冲突，程序会调用第二个散列函数来求值

H(k) = h(k, i) = (h1(k) + i * h2(k)) mod m    （必须保证T的长度m与h2(k) 互质，否则会出现无法生成下标的情况0）

伪代码实现：

h1(key)
    return key mod m

h2 (key)
    return 1 + (key mod (m-1))

H(key, i)
     return (h1(key) + i * h2(key)) mod m

insert (T, key)
    i = 0
    while true
        j =H(key, i)
        if T[j] ==NIL    // 判断当前位置是否空着
            T[j] = key
            return j
        else
            i = i + 1

search(T, key)
    i = 0
    while true
        j =H(key, i)
        if T[j] == key
            return j
        else if T[j] == NIL or i >= m
            return NIL
        else
            i = i +1

　　

 

4.利用STL搜索

 使用迭代器

在二分搜索中，STL提供了binary_search、lower_bound（返回一个迭代器，且该迭代器指向第一个不小于指定值得元素）、upper_bound等方法