Go 戈朗二进制搜索

我正在练习一个面试算法，现在用Go编码。目的是练习基本的面试算法，以及我的围棋技能。我正在尝试对一组数字进行二进制搜索

package main

import "fmt"

func main() {
    searchField := []int{2, 5, 8, 12, 16, 23, 38, 56, 72, 91}
    searchNumber := 23

    fmt.Println("Running Program")
    fmt.Println("Searching list of numbers: ", searchField)
    fmt.Println("Searching for number: ", searchNumber)

    numFound := false
    //searchCount not working. Belongs in second returned field
    result, _ := binarySearch2(searchField, len(searchField), searchNumber, numFound)
    fmt.Println("Found! Your number is found in position: ", result)
    //fmt.Println("Your search required ", searchCount, " cycles with the Binary method.")
}

func binarySearch2(a []int, field int, search int, numFound bool) (result int, searchCount int) {
    //searchCount removed for now.
    searchCount, i := 0, 0
    for !numFound {
        searchCount++
        mid := i + (field-i)/2
        if search == a[mid] {
            numFound = true
            result = mid
            return result, searchCount
        } else if search > a[mid] {
            field++
            //i = mid + 1 causes a stack overflow
            return binarySearch2(a, field, search, numFound)
        }
        field = mid
        return binarySearch2(a, field, search, numFound)
    }
    return result, searchCount
}

我遇到的主要问题是：

1） 当列表中的数字高于我的中间搜索时，我是真的在继续二进制搜索，还是已转为顺序搜索？我怎样才能解决这个问题？我放置的另一个选项已被注释掉，因为它会导致堆栈溢出

2） 我想添加一个步骤计数，以查看完成搜索需要多少步骤。也可以与其他搜索方法一起使用。如果我按原样打印搜索计数，它总是显示一。这是因为我需要在方法中返回它（并因此在标题中调用它）吗

---

我知道Go有一些方法可以简化这个过程。我正在努力增加我的知识和编码技能。非常感谢您的输入。

您没有正确地进行二进制搜索。首先，您的

for

循环是无用的，因为条件树中的每个分支都有一个return语句，所以它不能运行多个迭代。看起来您开始以迭代方式编写代码，然后切换到递归设置，但只转换了一半

二进制搜索的思想是，你有一个高索引和低索引，并搜索它们之间的中间点。您没有这样做，您只是增加

字段

变量并重试（这将导致您搜索每个索引两次，直到您通过运行列表末尾找到项目或segfault）。不过，在Go中，您不需要跟踪高索引和低索引，因为您可以根据需要简单地对搜索字段进行子切片

下面是一个更优雅的递归版本：

func binarySearch(a []int, search int) (result int, searchCount int) {
    mid := len(a) / 2
    switch {
    case len(a) == 0:
        result = -1 // not found
    case a[mid] > search:
        result, searchCount = binarySearch(a[:mid], search)
    case a[mid] < search:
        result, searchCount = binarySearch(a[mid+1:], search)
        if result >= 0 { // if anything but the -1 "not found" result
            result += mid + 1
        }
    default: // a[mid] == search
        result = mid // found
    }
    searchCount++
    return
}

func二进制搜索（a[]int，search int）（结果int，searchCount int）{
中：=长（a）/2
开关{
案例len（a）==0：
结果=-1//未找到
案例a[mid]>搜索：
结果，searchCount=binarySearch（a[：mid]，search）
案例a[mid]<搜索：
结果，searchCount=binarySearch（a[mid+1:]，search）
if result>=0{//if除-1“not found”结果之外的任何内容
结果+=中间+1
}
默认值：://a[mid]==搜索
结果=中//已找到
}
搜索计数++
返回
}

函数二进制搜索（数组[]int，目标int）int{
startIndex:=0
endIndex:=len（数组）-1
midIndex:=len（数组）/2
对于startIndex目标{
endIndex=midIndex-1
midIndex=（开始索引+结束索引）/2
持续
}
startIndex=midIndex+1
midIndex=（开始索引+结束索引）/2
}
返回-1
}

函数二进制搜索（a[]int，x int）int{
r:=-1//找不到
开始：=0
结束：=len（a）-1
对于start x{
结束=中间-1
}
}
返回r
}

为什么不搜索某些内容？我很感激对错误的解释。我现在知道的事情。现在有人能解释为什么在切换过程中方法调用中的冒号（：）允许传递值吗？嗯，是的，再次运行它，我忽略了将mid添加到结果中。更正版本：对于冒号，这称为子切片。表达式

s[a::

表示索引

a

之后的切片

s

，而表达式

s[：a]

表示索引

a

之前（但不包括）的切片

s

。例如，如果您有

s=int{0,1,2,3}

，则表达式

s[2://code>将为您提供
{2,3}
，而表达式
s[：2]
将为您提供
{0,1}
。你也可以做射程。例如，
s[1:3]
将为您提供
{1,2}
。方法调用解释中的冒号非常棒。非常感谢。“抓得好，”卡米尔季季季季奇说。贴子已更新并更正。
func BinarySearch(array []int, target int) int {
  startIndex := 0
  endIndex := len(array) - 1
  midIndex := len(array) / 2
  for startIndex <= endIndex {

    value := array[midIndex]

    if value == target {
        return midIndex
    }

    if value > target {
        endIndex = midIndex - 1
        midIndex = (startIndex + endIndex) / 2
        continue
    }

    startIndex = midIndex + 1
    midIndex = (startIndex + endIndex) / 2
}

  return -1
}

func BinarySearch(a []int, x int) int {
    r := -1 // not found
    start := 0
    end := len(a) - 1
    for start <= end {
        mid := (start + end) / 2;
        if a[mid] == x {
            r = mid // found
            break
        } else if a[mid] < x {
            start = mid + 1
        } else if a[mid] > x {
            end = mid - 1
        }
    }
    return r
}