binary-search

问题 I am trying to implement a binary search using objective-c blocks. I am using the function indexOfObject:inSortedRange:options:usingComparator: . Here is an example. // A pile of data. NSUInteger amount = 900000; // A number to search for. NSNumber* number = [NSNumber numberWithInt:724242]; // Create some array. NSMutableArray* array = [NSMutableArray arrayWithCapacity:amount]; for (NSUInteger i = 0; i < amount; ++i) {; [array addObject:[NSNumber numberWithUnsignedInteger:i]]; }

问题 I was writing up code for a binary search algorithm. Code: #include "cs50.h" int main(void) { int n = GetInt(); int value = GetInt(); int values[n]; for (int i = 0; i < n; i++) { printf("Put in number %i ", i + 1); values[i] = GetInt(); } int mid = (n - 1) / 2; int en = 0; int ex = n - 1; for (int i = 0, xt = i + 1; i < xt; i++) { if (value > values[mid]) { en = mid; mid = (en + ex) / 2; } else if (value < values[mid]) { ex = mid; mid = (en + ex) / 2; } else if (value == values[mid]) { printf

问题 The problem is to extend the binary search algorithm to find all occurrences of a target value in a sorted array in the most efficient way. Concretely speaking, the input of the algorithm is (1) a sorted array of integers, where some numbers may appear more than once, and (2) a target integer to be searched. The output of the algorithm should be a pair of index values, indicating the first and last occurrence of the integer in the array, if it does occur. The source code could be in c#, c, c+

问题 I'm looking for the mathematical proof, not just the answer. 回答1: The recurrence relation of binary search is (in the worst case) T(n) = T(n/2) + O(1) Using Master's theorem n is the size of the problem. a is the number of subproblems in the recursion. n/b is the size of each subproblem. (Here it is assumed that all subproblems are essentially the same size.) f (n) is the cost of the work done outside the recursive calls, which includes the cost of dividing the problem and the cost of merging

问题 I noticed that as of Ruby 2.0.0 the array class has a bsearch method that I was testing and I'm not getting the behavior I'd expect. Why does it return a value for 2 and 5 but nil for -1, 1, and 4? arr_in = [-1, 1, 2, 4, 5] arr_in.bsearch { |x| x == 3 } #=> nil arr_in.bsearch { |x| x == -1 } #=> nil arr_in.bsearch { |x| x == 1 } #=> nil arr_in.bsearch { |x| x == 2 } #=> 2 arr_in.bsearch { |x| x == 4 } #=> nil arr_in.bsearch { |x| x == 5 } #=> 5 回答1: arr_in = [-1, 1,2,4,5] arr_in.bsearch{ |x|

问题 I noticed that as of Ruby 2.0.0 the array class has a bsearch method that I was testing and I'm not getting the behavior I'd expect. Why does it return a value for 2 and 5 but nil for -1, 1, and 4? arr_in = [-1, 1, 2, 4, 5] arr_in.bsearch { |x| x == 3 } #=> nil arr_in.bsearch { |x| x == -1 } #=> nil arr_in.bsearch { |x| x == 1 } #=> nil arr_in.bsearch { |x| x == 2 } #=> 2 arr_in.bsearch { |x| x == 4 } #=> nil arr_in.bsearch { |x| x == 5 } #=> 5 回答1: arr_in = [-1, 1,2,4,5] arr_in.bsearch{ |x|

问题 This question is about the efficiency of a linear search vs. the efficiency of a binary search for a pre-sorted array in contiguous storage... I have an application written in fortran (77!). One frequent operation for my part of the code is to find the index in an array such that gx(i) <= xin < gx(i+1) . I've currently implemented this as a binary search -- sorry for the statement labels and goto -- I've commented what the equivalent statments would be using fortran 90... i=1 ih=nx/2 201

问题 What is the simplest way to do a binary search on an (already) sorted NSArray ? Some potential ways I have spotted so far include: The use of CFArrayBSearchValues (mentioned here) - would this work on an NSArray ? The method indexOfObject:inSortedRange:options:usingComparator: of NSArray assumes the array is sorted and takes an opts param of type NSBinarySearchingOptions - does this mean it performs a binary search? The docs just say: Returns the index, within a specified range, of an object

问题 I have been using my time off university to practice Java through coding algorithms. One of the algorithms I coded was the binary search: public class BinarySearch { private static int list[] = {3, 6, 7, 8, 9, 10}; public static void main(String[] args) { BinarySearch b = new BinarySearch(); b.binarySearch(list); } public void binarySearch(int[] args) { System.out.println("Binary search."); int upperBound = args.length; int lowerBound = 1; int midpoint = (upperBound + lowerBound) / 2; int

问题 Does anyone know a faster-than-linear algorithm for finding a duplicate in a sequential list of numbers? I'm working in Java now but any language or psuedo-code is fine. For example, given this int[] input: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 7 | 8 | 9 Output would be either index or value '7'. I know the obvious traversal at O(n) linear time, but I'm trying to see if this is possible via binary search at O(log n) time. 回答1: If you assume the numbers must start at 0 and be increasing by 1 you can