二分搜索算法 Go

说明

二分查找的数组必须是有序的，二分查找的优点是查找操作仅需要O(lgN)时间。

逻辑

首先传入的数组必须是有序的，然后算法开始时取整个数组，并通过对比将数组规模不停减半，直到发现符合寻找条件的元素为止（或者未能找到元素）。

代码

package arithmetic

import (
    "math"
)

//SearchBinary 二分查找
func SearchBinary(element interface{}, slice []interface{},
    funcCondition func(interface{}, interface{}) int) (int, bool) {

    var l, r = 0, len(slice) - 1
    var i = int((l + r + 1) / 2)
    for l != r {
        switch funcCondition(slice[i], element) {
        case -1: //slice[i] < element
            l = i + 1
            i = int((l + r + 1) / 2)
            continue
        case 0: //slice[i] == element
            return i, true
        case 1: //slice[i] > element
            r = i - 1
            i = int((l + r + 1) / 2)
            continue
        }
    }
    return len(slice), false
}

//InterfaceSearch 搜索接口
type InterfaceSearch interface {
    Len() int
    Condition(i int, element interface{}) int
    GetElement(i int) interface{}
}

//SearchBinaryOop 二分查找  面向对象
func SearchBinaryOop(element interface{}, slice InterfaceSearch) (int, bool) {

    var l, r = 0, slice.Len() - 1
    var i = int((l + r + 1) / 2)
    for l != r {
        switch slice.Condition(i, element) {
        case -1: //slice[i] < element
            l = i + 1
            i = int((l + r + 1) / 2)
            continue
        case 0: //slice[i] == element
            return i, true
        case 1: //slice[i] > element
            r = i - 1
            i = int((l + r + 1) / 2)
            continue
        }
    }
    return slice.Len(), false
}

代码说明

面向算法：通过闭包传入的判断条件判断两个元素是否相等，若相等返回元素所在数组下标，以及true 。若不相等，则通过对比元素大小，对剩余数组元素取中间下标继续循环对比。若最终未搜索到数据则返回数组长度，以及false。

面向对象：结构体通过实现接口，取代原本闭包传入的方式。

两种方式各有优缺点。主要在调用时，面向算法因为Go语言的特性问题，需要将结构数组转换成通用的[]interface{}，此部分比较耗时。两种代码实现方式都可用于自身结构数组。其他编程语言情况有所不同。具体调用方式见下文。

测试代码

package  main

import (
    "AZframework/arithmetic"
    "fmt"
)

//IntSlice []int
type IntSlice []int

func (s IntSlice) Len() int           { return len(s) }
func (s IntSlice) Condition(i int, element interface{}) int {

    if s[i] == element.(int) {
        return 0
    }

    if s[i] < element.(int) {
        return -1
    }

    return 1
}

func (s IntSlice) GetElement(i int) interface{} { return s[i] }

func main() {

    var intB = 2
    var sliceC = IntSlice{1, 2, 3, 4, 5, 6}

    var interSlice = make([]interface{}, len(sliceC))

    for i, d := range sliceC {
        interSlice[i] = d
    }

    var x3, y3 = arithmetic.SearchBinary(intB, interSlice, func(a interface{}, b interface{}) int {
        if a.(int) == b.(int) {
            return 0
        }

        if a.(int) < b.(int) {
            return -1
        }

        return 1
    })
    fmt.Printf("SearchBinary %t %d\n", y3, x3)

    var x4, y4 = arithmetic.SearchBinaryOop(intB, sliceC)
    fmt.Printf("SearchBinaryOop %t %d\n", y4, x4)

}

日志输出

SearchBinary true 1
SearchBinaryOop true 1