Go 如何在超大结构中查找范围内的ip

我有一个类似下面的结构，大约有10万个实体

我想在它上面循环并检查ip地址是否在范围内

我当前的代码：

type Users struct {
    Id        string
    Descr     string
    IpStart   string
    IpEnd     string
}
var users []*Users



func LookUpIP(IpAddress string) (string, string) {
    iptocheck := net.ParseIP(IpAddress)
    for _, elem := range users {
        if bytes.Compare(iptocheck, elem.IpStart) >= 0 && bytes.Compare(iptocheck, elem.IpEnd) <= 0 {
            fmt.Printf("%v is between %v and %v\n", IpAddress, elem.IpStart, elem.IpEnd)
            return elem.Id, elem.Descr 
        }
    }
    return "0", "null"
}

类型用户结构{
Id字符串
描述字符串
IpStart字符串
IpEnd字符串
}
var用户[]*用户
func LookUpIP（IP地址字符串）（字符串，字符串）{
iptocheck:=net.ParseIP（IpAddress）
对于u，元素：=范围用户{
如果bytes.Compare（iptocheck，elem.IpStart）>=0&&bytes.Compare（iptocheck，elem.IpEnd）我看到了两个简单的步骤

执行一次解析，并将IP地址存储为单个数字
按范围的开始和使用顺序排列范围
我看到了两个简单的步骤

执行一次解析，并将IP地址存储为单个数字
按范围的开始和使用顺序排列范围
作为使用二进制搜索以减少搜索时间的建议的补充，下面是go中的二进制搜索实现

但首先什么是二进制搜索？二进制搜索将一系列值分成两半，并继续缩小搜索范围，直到找到未知值。这是“分而治之”算法的经典示例

该算法返回与给定值相等的某个元素的索引（如果有多个这样的元素，则返回任意一个）。当找不到该元素时，还可以返回该元素的“插入点”（如果将该值插入数组中，该值将具有的索引）

递归方法

func binarySearch(a []float64, value float64, low int, high int) int {
    if high < low {
        return -1
    }
    mid := (low + high) / 2 // calculate the mean of two values
    if a[mid] > value {
        return binarySearch(a, value, low, mid-1)
    } else if a[mid] < value {
        return binarySearch(a, value, mid+1, high)
    }
    return mid
}

func binarySearch(a []float64, value float64) int {
    low := 0
    high := len(a) - 1
    for low <= high {
        mid := (low + high) / 2
        if a[mid] > value {
            high = mid - 1
        } else if a[mid] < value {
            low = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

func二进制搜索（a[]float64，值float64，低int，高int）int{
如果高<低{
返回-1
}
mid:=（低+高）/2//计算两个值的平均值
如果[mid]>值{
返回二进制搜索（a、值、低、中1）
}如果[mid]<值{
返回二进制搜索（a，值，中+1，高）
}
中途返回
}

迭代法

func binarySearch(a []float64, value float64, low int, high int) int {
    if high < low {
        return -1
    }
    mid := (low + high) / 2 // calculate the mean of two values
    if a[mid] > value {
        return binarySearch(a, value, low, mid-1)
    } else if a[mid] < value {
        return binarySearch(a, value, mid+1, high)
    }
    return mid
}

func binarySearch(a []float64, value float64) int {
    low := 0
    high := len(a) - 1
    for low <= high {
        mid := (low + high) / 2
        if a[mid] > value {
            high = mid - 1
        } else if a[mid] < value {
            low = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

func二进制搜索（a[]float64，值float64）int{
低：=0
高：=透镜（a）-1
低值{
高=中-1
}如果[mid]<值{
低=中+1
}否则{
中途返回
}
}
返回-1
}

但是，如果您查看一下，您可以发现已经有一种基于二进制搜索的排序算法。因此，这可能是最好的选择。
作为使用二进制搜索缩短搜索时间的建议的补充，下面是go中的二进制搜索实现

但首先什么是二进制搜索？二进制搜索将一系列值分成两半，并继续缩小搜索范围，直到找到未知值。这是“分而治之”算法的经典示例

该算法返回与给定值相等的某个元素的索引（如果有多个这样的元素，则返回任意一个）。当找不到该元素时，还可以返回该元素的“插入点”（如果将该值插入数组中，该值将具有的索引）

递归方法

func binarySearch(a []float64, value float64, low int, high int) int {
    if high < low {
        return -1
    }
    mid := (low + high) / 2 // calculate the mean of two values
    if a[mid] > value {
        return binarySearch(a, value, low, mid-1)
    } else if a[mid] < value {
        return binarySearch(a, value, mid+1, high)
    }
    return mid
}

func binarySearch(a []float64, value float64) int {
    low := 0
    high := len(a) - 1
    for low <= high {
        mid := (low + high) / 2
        if a[mid] > value {
            high = mid - 1
        } else if a[mid] < value {
            low = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

func二进制搜索（a[]float64，值float64，低int，高int）int{
如果高<低{
返回-1
}
mid:=（低+高）/2//计算两个值的平均值
如果[mid]>值{
返回二进制搜索（a、值、低、中1）
}如果[mid]<值{
返回二进制搜索（a，值，中+1，高）
}
中途返回
}

迭代法

func binarySearch(a []float64, value float64, low int, high int) int {
    if high < low {
        return -1
    }
    mid := (low + high) / 2 // calculate the mean of two values
    if a[mid] > value {
        return binarySearch(a, value, low, mid-1)
    } else if a[mid] < value {
        return binarySearch(a, value, mid+1, high)
    }
    return mid
}

func binarySearch(a []float64, value float64) int {
    low := 0
    high := len(a) - 1
    for low <= high {
        mid := (low + high) / 2
        if a[mid] > value {
            high = mid - 1
        } else if a[mid] < value {
            low = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

func二进制搜索（a[]float64，值float64）int{
低：=0
高：=透镜（a）-1
低值{
高=中-1
}如果[mid]<值{
低=中+1
}否则{
中途返回
}
}
返回-1
}

但是，如果你仔细观察一下，你会发现有一个已经实现的基于二进制搜索的排序算法。因此，这可能是最好的选择。
最初的想法是将用户信息存储在地图中，ip地址作为密钥。这样，您就不必在搜索时遍历ip地址。我可以这样做吗？因为我想知道ip:123.123.123.123是否在123.123.123.1和123.123.123.250的范围内？一个ip会落入多个范围吗？也就是说，像
123.123.123.1->123.123.123.250
和
123.123.123.128->123.123.124.1
这样的2+用户范围是否适用于
。这样，您就不必在搜索时遍历ip地址。我可以这样做吗？因为我想知道ip:123.123.123.123是否在123.123.123.1和123.123.123.250的范围内？一个ip会落入多个范围吗？也就是说，
123.123.123.123
是否适用于2+用户范围，如
123.123.123.1->123.123.123.250
和
123.123.123.128->123.123.124.1
？