Objective c 从NSArray中查找小于给定数字的最大数字

假设我有一个整数int[]的排序数组，我想搜索最接近某个输入数字的较小值

例如，如果数组包含

1

、

23

、

57

、

59

、

120

，且输入为

109

，则输出应为

59

。 我已经试过了，但效果并不理想

NSTimeInterval currentTime = self.player.currentTime;
NSInteger playerTime=currentTime;
NSUInteger index = [_timesArray indexOfObject:@(playerTime)
                                inSortedRange:NSMakeRange(0, _timesArray.count-1)
                                      options:NSBinarySearchingFirstEqual | NSBinarySearchingInsertionIndex
                              usingComparator:^(id a, id b) {
                                  return [a compare:b];
                              }];

---

正如我之前所说：“你们已经对数组进行了排序，你们需要的是从最大的数到最小的数……这里的算法很简单！”

NSNumber*givenNumber=@（105）；
对于（NSNumber*项在[@[@（1），@（23），@（57），@（59），@（120）]反向对象枚举器]）{
//向下
if（item.integerValue

正如我之前所说：“您已经对数组进行了排序，您需要的是从最大的数向下移动到最小的数……这里的算法很简单！”

NSNumber*givenNumber=@（105）；
对于（NSNumber*项在[@[@（1），@（23），@（57），@（59），@（120）]反向对象枚举器]）{
//向下
if（item.integerValue

正如我之前所说：“您已经对数组进行了排序，您需要的是从最大的数向下移动到最小的数……这里的算法很简单！”

NSNumber*givenNumber=@（105）；
对于（NSNumber*项在[@[@（1），@（23），@（57），@（59），@（120）]反向对象枚举器]）{
//向下
if（item.integerValue

正如我之前所说：“您已经对数组进行了排序，您需要的是从最大的数向下移动到最小的数……这里的算法很简单！”

NSNumber*givenNumber=@（105）；
对于（NSNumber*项在[@[@（1），@（23），@（57），@（59），@（120）]反向对象枚举器]）{
//向下
if（item.integerValue< /代码> 
可以用在O（LG n）中运行的BialySyxChuly-Al算法求解，但不知道Objto-C，所以我将用C++给出代码。
我假设给定的元素不在数组中
int binary_search_like(int s[], int key, int low, int high)
{
    int middle; 
    if (low > high) return (s[high]); 

    middle = (low + high) / 2;

    if (s[middle] > key)
        return(binary_search_like(s, key, low, middle - 1));
    else
        return(binary_search_like(s, key, middle + 1, high));
}

int Search(int s[], int key, int size){

    if (key > s[size - 1]) return s[size - 1];
    // Check if key < smallest element , give error !

    return binary_search_like(s, key, 0, size);

 }

int二进制搜索（int s[]，int键，int低，int高）
{
中间；
如果（低>高）返回（高）；
中等=（低+高）/2；
如果（s[中间]>键）
返回（类似于二进制搜索（s，key，low，middle-1））；
其他的
return（类似于二进制搜索的（s，key，middle+1，high））；
}
整数搜索（整数s[]，整数键，整数大小）{
如果（key>s[size-1]）返回s[size-1]；
//检查键是否<最小元素，给出错误！
返回类似于搜索的二进制文件（s，键，0，大小）；
}
< /代码> 
可以用在O（LG n）中运行的BialySyxChuly-Al算法求解，但不知道Objto-C，所以我将用C++给出代码。
我假设给定的元素不在数组中
int binary_search_like(int s[], int key, int low, int high)
{
    int middle; 
    if (low > high) return (s[high]); 

    middle = (low + high) / 2;

    if (s[middle] > key)
        return(binary_search_like(s, key, low, middle - 1));
    else
        return(binary_search_like(s, key, middle + 1, high));
}

int Search(int s[], int key, int size){

    if (key > s[size - 1]) return s[size - 1];
    // Check if key < smallest element , give error !

    return binary_search_like(s, key, 0, size);

 }

int二进制搜索（int s[]，int键，int低，int高）
{
中间；
如果（低>高）返回（高）；
中等=（低+高）/2；
如果（s[中间]>键）
返回（类似于二进制搜索（s，key，low，middle-1））；
其他的
return（类似于二进制搜索的（s，key，middle+1，high））；
}
整数搜索（整数s[]，整数键，整数大小）{
如果（key>s[size-1]）返回s[size-1]；
//检查键是否<最小元素，给出错误！
返回类似于搜索的二进制文件（s，键，0，大小）；
}
< /代码> 
可以用在O（LG n）中运行的BialySyxChuly-Al算法求解，但不知道Objto-C，所以我将用C++给出代码。
我假设给定的元素不在数组中
int binary_search_like(int s[], int key, int low, int high)
{
    int middle; 
    if (low > high) return (s[high]); 

    middle = (low + high) / 2;

    if (s[middle] > key)
        return(binary_search_like(s, key, low, middle - 1));
    else
        return(binary_search_like(s, key, middle + 1, high));
}

int Search(int s[], int key, int size){

    if (key > s[size - 1]) return s[size - 1];
    // Check if key < smallest element , give error !

    return binary_search_like(s, key, 0, size);

 }

int二进制搜索（int s[]，int键，int低，int高）
{
中间；
如果（低>高）返回（高）；
中等=（低+高）/2；
如果（s[中间]>键）
返回（类似于二进制搜索（s，key，low，middle-1））；
其他的
return（类似于二进制搜索的（s，key，middle+1，high））；
}
整数搜索（整数s[]，整数键，整数大小）{
如果（key>s[size-1]）返回s[size-1]；
//检查键是否<最小元素，给出错误！
返回类似于搜索的二进制文件（s，键，0，大小）；
}
< /代码> 
可以用在O（LG n）中运行的BialySyxChuly-Al算法求解，但不知道Objto-C，所以我将用C++给出代码。
我假设给定的元素不在数组中
int binary_search_like(int s[], int key, int low, int high)
{
    int middle; 
    if (low > high) return (s[high]); 

    middle = (low + high) / 2;

    if (s[middle] > key)
        return(binary_search_like(s, key, low, middle - 1));
    else
        return(binary_search_like(s, key, middle + 1, high));
}

int Search(int s[], int key, int size){

    if (key > s[size - 1]) return s[size - 1];
    // Check if key < smallest element , give error !

    return binary_search_like(s, key, 0, size);

 }

int二进制搜索（int s[]，int键，int低，int高）
{
中间；
如果（低>高）返回（高）；
中等=（低+高）/2；
如果（s[中间]>键）
返回（类似于二进制搜索（s，key，low，middle-1））；
其他的
return（类似于二进制搜索的（s，key，middle+1，high））；
}
整数搜索（整数s[]，整数键，整数大小）{
如果（key>s[size-1]）返回s[size-1]；
//检查键是否<最小元素，给出错误！
返回类似于搜索的二进制文件（s，键，0，大小）；
}
对于您提供的示例数据，您的代码确实能按预期工作：

NSArray *_timesArray = @[@1, @23, @57, @59, @120];
NSTimeInterval currentTime = 109;
NSInteger playerTime=currentTime;
NSUInteger index = [_timesArray indexOfObject:@(playerTime)
                                inSortedRange:NSMakeRange(0, _timesArray.count-1)
                                      options:NSBinarySearchingFirstEqual | NSBinarySearchingInsertionIndex
                              usingComparator:^(id a, id b) {
                                  return [a compare:b];
                              }];
NSLog(@"Index: %lu", (unsigned long)index);

输出：

Index: 4

检查您的输入。很可能它们不是您认为的那样。
对于您提供的示例数据，您的代码确实可以按预期工作：

NSArray *_timesArray = @[@1, @23, @57, @59, @120];
NSTimeInterval currentTime = 109;
NSInteger playerTime=currentTime;
NSUInteger index = [_timesArray indexOfObject:@(playerTime)
                                inSortedRange:NSMakeRange(0, _timesArray.count-1)
                                      options:NSBinarySearchingFirstEqual | NSBinarySearchingInsertionIndex
                              usingComparator:^(id a, id b) {
                                  return [a compare:b];
                              }];
NSLog(@"Index: %lu", (unsigned long)index);

输出：

Index: 4

检查您的输入。很可能它们不是您认为的那样。
对于您提供的示例数据，您的代码确实可以按预期工作：

NSArray *_timesArray = @[@1, @23, @57, @59, @120];
NSTimeInterval currentTime = 109;
NSInteger playerTime=currentTime;
NSUInteger index = [_timesArray indexOfObject:@(playerTime)
                                inSortedRange:NSMakeRange(0, _timesArray.count-1)
                                      options:NSBinarySearchingFirstEqual | NSBinarySearchingInsertionIndex
                              usingComparator:^(id a, id b) {
                                  return [a compare:b];
                              }];
NSLog(@"Index: %lu", (unsigned long)index);

输出：

Index: 4

检查您的输入。很可能它们不是您认为的那样。
对于您提供的示例数据，您的代码确实可以按预期工作：

NSArray *_timesArray = @[@1, @23, @57, @59, @120];
NSTimeInterval currentTime = 109;
NSInteger playerTime=currentTime;
NSUInteger index = [_timesArray indexOfObject:@(playerTime)
                                inSortedRange:NSMakeRange(0, _timesArray.count-1)
                                      options:NSBinarySearchingFirstEqual | NSBinarySearchingInsertionIndex
                              usingComparator:^(id a, id b) {
                                  return [a compare:b];
                              }];
NSLog(@"Index: %lu", (unsigned long)index);

输出：

Index: 4

检查您的输入。很可能它们不是您所认为的。
您已经对数组进行了排序，您需要的是从最大值向下移动到最大值