问题描述

输入一个数，求有序整数Set<Integer>集合内最近且大于他的数

输入一个数，求有序整数Set集合内最近的数
如：Set orders = new HashSet();
orders.add(8);
orders.add(3);
orders.add(4);
orders.add(7);
orders.add(6);
orders.add(5);

    输入2：得到3；
    输入8：找不到返回null；

解决方案

我算法不是很好,所以想要咨询有没有更好的算法
我最后还是直接遍历了集合去查找
一个往上找一个往下找:
public static Integer isUpSearch(List orders, int des, boolean isUp) {
int size = orders.size();
for (int i = size; i >= 0; i--) {

    }
    return isUp ? upLoop(orders, des) : downLoop(orders, des);
}

private static Integer downLoop(List<Integer> orders, int des) {
    int size = orders.size();
    for (int i = (size - 1); i >= 0; i--) {
        if (des > orders.get(i)) {
            return orders.get(i);
        }
    }
    return null;
}

这种方式用二分查找应该是最块的,由于没时间了,我暂时用保守的方式
谢谢大家回答

解决方案二：

 既然是有序序列，那么可以用二分查找，大概的代码如下：
int start = 0;
int end = orders.length() - 1;
while (start != end)
{
    pos = (end - start) / 2;
    if (orders.get(pos) < find)
        {
            start = pos + 1;
        }
        else
        {
            end = pos;
        }
}
if (pos == orders.length() - 1) return null;
return pos + 1;

解决方案三：

实现思路：
首先，对集合进行排序；其次，执行查找过程，先看能否找到输入的值，如果找到且该元素不是最后一个元素的话，则返回其后一个元素；
最后，如果找不到这个输入值，就找第一个比其大的数并返回。
其他情况，均返回null。实现代码参考：

 import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class OrderTest {
    public static void main(String[] args) {
        Set orders = new HashSet();
         orders.add(8);
         orders.add(3);
         orders.add(4);
         orders.add(7);
         orders.add(6);
         orders.add(5);
         System.out.println(getLatestLargerNumber(orders,2));
         System.out.println(getLatestLargerNumber(orders,8));
         System.out.println(getLatestLargerNumber(orders,6));
    }

    //查找第一个大等于number的数
    public static Integer getLatestLargerNumber(Set<Integer> list,int number){
        //集合为空或者只有一个元素时返回空
        if(list==null||list.size()==0){
            return null;
        }

        //先对Set集合进行排序
        Object[] numbers = (Object[]) list.toArray();
        Arrays.sort(numbers);

        Integer value = null;
        int length = numbers.length;
        for(int i =0;i<length;i++){
            int current = (Integer)numbers[i];
            //找到number,且它不是最后一个元素，那么i+1位置处的值一定是第一个大于number的数
            if(current==number){
                if(i+1<length){
                    value = (Integer)numbers[i+1];
                }
                break;
            }

            //找不到number时，就找第一个比其大的元素
            if(current>number){
                value= current;
                break;
            }
        }

        return value;
    }
}

测试结果，ok，跟你需求描述的一致。

解决方案四：

直接用本身的方法接口

 public static void main(String[] args) {
        Set orders = new HashSet();
        orders.add(8);
        orders.add(3);
        orders.add(4);
        orders.add(7);
        orders.add(6);
        orders.add(5);
        orders.add(2);
        List items = new ArrayList(new TreeSet(orders));
        Integer needFound = 2;
        // 输入2：得到3；
        Integer x = (Integer) (items.indexOf(needFound) < items.size() - 1 ? items.get(items.indexOf(needFound)+1)
                : null);
        System.out.println("输入2： 测试结果-->" + x);
        // 输入8：找不到返回null；
        needFound = 8;
        x = (Integer) (items.indexOf(needFound) < items.size() - 1 ? items.get(items.indexOf(needFound)+1) : null);
        System.out.println("输入8：测试结果-->" + x);
    }

解决方案五：

输入2：得到3；

这个你将2 数据放到集合中，然后对集合进行排序 ，然后 排序好取 2后面的数据 。当然取不到就报null

解决方案六：

public static void main(String[] args) {
Set set = new TreeSet();
set.add(1);
set.add(3);
set.add(5);
set.add(7);
set.add(9);
set.add(2);
set.add(4);
set.add(6);
set.add(8);
set.add(10);
Scanner sc = new Scanner(System.in);
System.out.println("输入查询的数");
int id = sc.nextInt();
id = DriveNetMainWindow.shuju(set, id);
if (id == 0) {
System.out.println("找不到返回null");
} else {
System.out.println("得到"+id);
}
}

public static int shuju(Set<Integer> set, int id) {
    Iterator<Integer> it = set.iterator();
    while (it.hasNext()) {
        int i = it.next();
        if (i - id > 0) {
            return i;
        }
    }
    return 0;
}

解决方案七：

有序集是已经排序了的，二分查找即可
如果用集合，集合不暴露内部状态，有点麻烦

解决方案八：

有序集是已经排序了的，二分查找即可
如果用集合，集合不暴露内部状态，有点麻烦

解决方案九：

有序集是已经排序了的，二分查找即可
如果用集合，集合不暴露内部状态，有点麻烦

解决方案十：

既然已经的有序的集合了，直接遍历呗，降序集合当第n个大于，第N+1个小于时，第N个就是，反之升序集合N+1个就是