python中的跳转搜索算法

我正在尝试用python实现跳转搜索

这是密码

'''
2 jump search
'''
import math
def jump_search(arr,search):
    interval = int(math.sqrt(len(arr)))
    for i in range(0,len(arr),interval):
        if arr[i] >  search:
            chunk = i
            break
        if arr[i] ==  search:
            return i
    arr_ls = arr[chunk-interval:chunk]
    ind = [i for i,d in enumerate(arr_ls) if d==search]
    return chunk-interval+ind[0]
arr = [ i for i in range(1,200,15)]

res = jump_search(arr, 121)
print(res)

以下是我面临的问题：

最后一块正在跳过

改进版？ 我也不认为我的代码干净和简短

---

目前，如果

search

变量出现在最后一个区块中，则区块将不会初始化。因此，您一定是遇到了错误。那么，你为什么不具体检查一下最后一次间歇呢。我添加了一个

标志

变量来检查它。如果找到了chunk，那么很好，否则我们必须看到最后一个间隔

import math
def jump_search(arr,search):
    flag = 0
    interval = int(math.sqrt(len(arr)))
    for i in range(0,len(arr),interval):
        if arr[i] >  search:
            chunk = i
            flag = 1
            break
        if arr[i] ==  search:
            return i
    if flag==0:
        c=i
        for j in arr[i:]:
            if j==search:
                return c
            c+=1
    else:
        arr_ls = arr[chunk-interval:chunk]
        ind = [i for i,d in enumerate(arr_ls) if d==search]
        return chunk-interval+ind[0]
arr = [ i for i in range(1,200,15)]
res = jump_search(arr, 196)
print(res) 
# prints 13

此外，如果您跟踪的是

下限

，而不是您现在正在做的

上限

，那么您就不必执行所有这些操作。因此，为了使您的代码更好（这是您要求的），请尝试以下方法：

import math
def jump_search(arr,search):
    low = 0
    interval = int(math.sqrt(len(arr)))
    for i in range(0,len(arr),interval):
        if arr[i] < search:
            low = i
        elif arr[i] == search:
            return i
        else:
            break # bigger number is found
    c=low
    for j in arr[low:]:
        if j==search:
            return c
        c+=1
    return "Not found"

arr = [ i for i in range(1,200,15)]
res = jump_search(arr, 196)
print(res)
# prints 13

导入数学
def跳转搜索（arr，搜索）：
低=0
间隔=int（数学sqrt（len（arr）））
对于范围内的i（0，长度（arr），间隔）：
如果arr[i]<搜索：
低=i
elif arr[i]==搜索：
返回i
其他：
break#找到更大的数字
c=低
对于arr中的j[低：]：
如果j==搜索：
返回c
c+=1
返回“未找到”
arr=[i代表范围内的i（1200,15）]
res=跳转搜索（arr，196）
打印（res）
#印刷品13

目前，如果最后一个区块中存在

搜索变量，则区块将不会初始化。因此，您一定是遇到了错误。那么，你为什么不具体检查一下最后一次间歇呢。我添加了一个
标志
变量来检查它。如果找到了chunk，那么很好，否则我们必须看到最后一个间隔

import math
def jump_search(arr,search):
    flag = 0
    interval = int(math.sqrt(len(arr)))
    for i in range(0,len(arr),interval):
        if arr[i] >  search:
            chunk = i
            flag = 1
            break
        if arr[i] ==  search:
            return i
    if flag==0:
        c=i
        for j in arr[i:]:
            if j==search:
                return c
            c+=1
    else:
        arr_ls = arr[chunk-interval:chunk]
        ind = [i for i,d in enumerate(arr_ls) if d==search]
        return chunk-interval+ind[0]
arr = [ i for i in range(1,200,15)]
res = jump_search(arr, 196)
print(res) 
# prints 13

此外，如果您跟踪的是
下限
，而不是您现在正在做的
上限
，那么您就不必执行所有这些操作。因此，为了使您的代码更好（这是您要求的），请尝试以下方法：

import math
def jump_search(arr,search):
    low = 0
    interval = int(math.sqrt(len(arr)))
    for i in range(0,len(arr),interval):
        if arr[i] < search:
            low = i
        elif arr[i] == search:
            return i
        else:
            break # bigger number is found
    c=low
    for j in arr[low:]:
        if j==search:
            return c
        c+=1
    return "Not found"

arr = [ i for i in range(1,200,15)]
res = jump_search(arr, 196)
print(res)
# prints 13

导入数学
def跳转搜索（arr，搜索）：
低=0
间隔=int（数学sqrt（len（arr）））
对于范围内的i（0，长度（arr），间隔）：
如果arr[i]<搜索：
低=i
elif arr[i]==搜索：
返回i
其他：
break#找到更大的数字
c=低
对于arr中的j[低：]：
如果j==搜索：
返回c
c+=1
返回“未找到”
arr=[i代表范围内的i（1200,15）]
res=跳转搜索（arr，196）
打印（res）
#印刷品13
您的代码跳过最后一个区块，因为for循环的步长大于最后一个区块长度。若您尝试搜索列表中不存在的元素，它也会失败

总之，这对您来说应该很有用：

import math


def jump_search(arr, search):
    interval = int(math.sqrt(len(arr)))
    i = 0
    # set i to zero if list is empty
    for i in range(0, len(arr), interval):
        if arr[i] > search:
            break
        if arr[i] == search:
            return i
    else:
        # if loop exited normaly - add interval to i, so last chuck is included too
        i += interval

    last_chunk = arr[i - interval:i]

    # iterate directly and simply break if item found
    for ind, val in enumerate(last_chunk):
        if val == search:
            break
    else:
        # if loop exited normaly - item not found in chunk
        # return None instead of index
        return None
    return i - interval + ind

您的代码跳过最后一个块，因为for循环的步长大于最后一个块的长度。若您尝试搜索列表中不存在的元素，它也会失败

总之，这对您来说应该很有用：

import math


def jump_search(arr, search):
    interval = int(math.sqrt(len(arr)))
    i = 0
    # set i to zero if list is empty
    for i in range(0, len(arr), interval):
        if arr[i] > search:
            break
        if arr[i] == search:
            return i
    else:
        # if loop exited normaly - add interval to i, so last chuck is included too
        i += interval

    last_chunk = arr[i - interval:i]

    # iterate directly and simply break if item found
    for ind, val in enumerate(last_chunk):
        if val == search:
            break
    else:
        # if loop exited normaly - item not found in chunk
        # return None instead of index
        return None
    return i - interval + ind

这是否可以被视为（不完全是一种改进），而是作为上述代码的替代方案

def jumpSearch(a,m,x):
    for i in range(0,len(a),m):
        if a[i]==x:
           return i
        elif a[i]>x:
           high = i
           break

    for j in range(high,high-m,-1):
        if a[j]==x:
           return j

这是否可以被视为（不完全是一种改进），而是作为上述代码的替代方案

def jumpSearch(a,m,x):
    for i in range(0,len(a),m):
        if a[i]==x:
           return i
        elif a[i]>x:
           high = i
           break

    for j in range(high,high-m,-1):
        if a[j]==x:
           return j

请阅读，并不是每个人都想跟随链接，所以在你的问题中包括所有必要的信息，并举例说明所需的输入/输出。关于链接，我想我已经添加了所有信息哪些输入不起作用？列表的最后一个元素
196
请阅读，并不是每个人都想跟随链接，因此，在您的问题中包括所有必要的信息，并提供所需输入/输出的示例。关于链接，我想我已经添加了所有信息哪些输入不起作用？列表的最后一个元素
196
谢谢，
I+=interval
解决了我的问题：）。让我不舒服的是，假设我的间隔是4，最后一个块只包含2个元素，因此我的
i+4
需要额外的索引，但是python处理得很顺利。两个答案都很完美，很难决定哪一个是正确的：（@TarunK你可以试试：
[1,2,3][：10]
例如，请查看没有什么不好的事情发生。切片是安全的。假设使用整数作为参数，则不会导致错误。谢谢，
i+=interval
解决了我的问题：）。让我不舒服的是，假设我的间隔是4，最后一个块只包含2个元素，因此我的
i+4
需要额外的索引，但是python处理得很顺利。两个答案都很完美，很难决定哪一个是正确的：（@TarunK你可以试试：
[1,2,3][：10]
举个例子，看看没有什么不好的事情发生。切片是安全的。假设你使用整数作为参数，它不会导致错误。很好，真的很有用。我喜欢第二种方法（即兴）一个小建议，如果在早期发现这个数，
arr[low:]
将包含所有元素直到结束，我建议您使用
arr[low:low+interval]
来限制和节省时间。这两个答案都是完美的，很难决定哪一个是正确的：（@TarunK您是对的，但我认为您没有意识到这样一个事实，即循环只会在max
interval-1
次上运行，不是吗？因此，当您使用
arr[low:low+interval]
而不是
arr[low:]
。两者都可以。绝对正确，可能是因为我使用了列表理解。如果我想搜索16（在索引1处），
arr[low:low+interval]
将给我[16,31,46,61]（将执行4行搜索），而在
arr[low:
（将执行18行搜索）.完美，非常有用。我喜欢第二种方法（即兴）一个小建议，如果在早期阶段找到数字，
arr[low:
将占用所有元素直到结束，我建议您使用
arr[low:low+interval]
来限制和节省时间。两个答案都是完美的，很难确定哪一个是正确的：（@TarunK您是对的，但我认为您没有意识到这样一个事实，即循环只会以max
interval-1
的次数运行，不是吗？因此，使用
arr[l]时没有效率优化