Search sorted List for closest and less than

Question

Consider some long called X and a sorted List<Long>. What is the most efficient algorithm to find the index or value in the List<Long> that is (i) less than X, and (ii) The closest to X on the number line (assuming condition (i) has been satsified)?

For example this could be a problem setup:

long X = 500;
List<Long> foo = new Arraylist<Long>();
foo.add(450L);
foo.add(451L);    
foo.add(499L);
foo.add(501L);
foo.add(550L);

Collections.sort(foo); // It's always sorted.

I would like the algorithm to either return 499 or to return the index associated with 499 (in this case i=2).

@JeroenVannevel Yes the list is always sorted using `Collections.sort()` — user2763361, Oct 05 '13 at 14:00
Please see this link for find closest value in the list.. https://stackoverflow.com/questions/26885198/find-closest-factor-to-a-number-of-a-number?answertab=active#tab-top — Nikhil Gupta, Nov 22 '14 at 22:40

Rohit Jain · Accepted Answer · 2013-10-05T14:05:06.850

17

Given that the values in your list are unique, I would suggest you to use a Set, more specifically a TreeSet, as you are anyways sorting your list. You can use the NavigableSet#floor(E) method which does exactly what you want.

Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.

So, the code would look like:

long X = 500;
NavigableSet<Long> foo = new TreeSet<Long>();

foo.add(450L);
foo.add(451L);    
foo.add(499L);
foo.add(501L);
foo.add(550L);

System.out.println(foo.floor(X));   // 499

The method would also work for user-defined objects. Just you have to pass a Comparator<YourClass> to the TreeSet constructor while instantiating it.

edited Oct 05 '13 at 14:05

answered Oct 05 '13 at 13:59

Rohit Jain

209,639
45
409
525

Does my `foo` have to be sorted in the `NavigableSet`? – user2763361 Oct 05 '13 at 14:03
@user2763361 They will automatically be sorted, as you are using a `TreeSet` here. It orders the element based on their natural ordering, or on whatever `Comparator` you use while creating it. – Rohit Jain Oct 05 '13 at 14:03
Is there a similar object for when my list contains repeat values (but could still be sorted)? – user2763361 Oct 05 '13 at 14:09
For repeat values this won't hold. The method is applicable just for `Set`. May be you can convert the list to a `Set`, use this method to find the closest match, and then get all those match from the list. That would of course require you to create an extra object of `Set`. – Rohit Jain Oct 05 '13 at 14:10
How would I typecast a `List` called `foo` to a `TreeSet`? Do I just put it into the constructor? – user2763361 Oct 05 '13 at 14:28
@user2763361 Yes, you have to use the parameterized `TreeSet` constructor that takes a `Collection`. You can't typecast. They are incompatible types. – Rohit Jain Oct 05 '13 at 14:28
`NavigableSet#floor` can return `null` if there is nothing less than or equal to its argument. He was probably working a simple challenge problem or a work assignment that wanted to stress a binary search algorithm with O(1) memory instead of maintaining a concurrent `Set` with O(n) memory and the same find complexity of O(logn) as the binary search. – user904963 Nov 24 '21 at 21:07

score 6 · Answer 2 · answered Oct 05 '13 at 14:25

You can use java's Collections.binarySearch for this, since your list is sorted.

In the spec, binary search returns:

the index of the search key, if it is contained in the list; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the list: the index of the first element greater than the key, or list.size() if all elements in the list are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.

First off, if you binary search and the element is in the list, you'll get a positive value (the index of the element), and can just return that (or if you still want an element that's less you can just walk backwards from there until you find one).

Otherwise, if you search for something that isn't in the list you can work backward from the return value to the index you want. If you search for 500 in your example list, the algorithm would return (-3 - 1) = -4. Thus, you can add 1 to get back to the insertion point (-3), and then multiply by -1 and subtract 1 to get the index BEFORE the first element GREATER than the one you searched for, which will either be an index that meets your 2 criteria OR -1 if all elements in the list are greater than the one you searched for.

The advantage of using binary search over a tree set is that it will likely have less overhead.

score 5 · Answer 3 · answered Nov 22 '14 at 22:42

/*Find the Closest Number in the list * @param list of Integers * @param num to the number find their closest * @return Closest number * */

public static int findClosestNumber(List list, int num) {
    if (list.size() > 0) { // Check list does not empty
        int smaller =
            (Integer)Collections.min(list); // get min number from the list
        int larger =
            (Integer)Collections.max(list); // get max number from the list

        for (int i = 0; i < list.size(); i++) { //Traverse list
            if (num == (Integer)list.get(i))   //if find the passed number in the list
                return num;                     //than return num
            if (num > (Integer)list.get(i) && smaller < (Integer)list.get(i)) // find nearest smaller
                smaller = (Integer)list.get(i);
            if (num < (Integer)list.get(i) && larger > (Integer)list.get(i)) // find nearest larger
                larger = (Integer)list.get(i);
        }
        return (num - smaller < larger - num ? smaller : larger); // return closest number
    }
return 0;
}

}

Using an O(n) algorithm on a sorted list is ridiculous. Look up binary search, which finds a number in O(logn). — user904963, Nov 24 '21 at 18:03

Search sorted List for closest and less than

3 Answers3

Linked