0

我有一个带有数字的数组，并且该数组未排序。用户可以从数组中删除数字。但是用户应该能够稍后添加数字。

基本上我想在数据库中写入 id。用户可以删除行，但如果他添加行，则id 应该是已删除行中的缺失数字。

目前我这样解决它：

for (Object[] object : data) {
    if ((int) object[1] > id) {
        id = (int) object[1];
    }
}

但是这样我只能得到最大的数字而不是丢失的数字。我怎样才能得到一个丢失的号码？

例子：

4, 2, 3, 1 用户删除第 2 行和第 4 行所以我有

3, 1 现在我想计算或使用 if 语句来获取 2，如果用户添加另一行，则返回 4。

请记住，用户可以关闭程序，因此无法将数字保存在其他数组中！

  • 谢谢你的帮助
4

5 回答 5

1

看看下面的代码..可能会有所帮助

    int data[]={1,2,4};
    int i=1;
    for(Object object : data){
        if((Integer)object!=i++)
            break;
    }
    System.out.println(i-1);//This will print 3.
于 2013-08-22T12:03:55.310 回答
1

从您的示例中，将数字从头到尾相加，1+2+3+4 = 10，然后减去您拥有的数字的总和，1+2+4 = 7

所以 10 - 7 = 3（缺失的数字）

-------------------------------------------------- --EDIT ---------------- 这个怎么样？

public class SandBox7 {
public static void main(String[] args) {
    Integer[] array = new Integer[] { 1, 4, 9 };
    SandBox7 s = new SandBox7();
    List<Integer> mis = s.getMissingNumbers(array);
}

public List<Integer> getMissingNumbers(Integer[] in) {
    int max = getMaximum(in);
    // System.out.println(max);
    List<Integer> numbers = Arrays.asList(in);

    ArrayList<Integer> missing = new ArrayList<>();
    for (int i = 1; i < max; i++) {

        if (!numbers.contains(i)) {
            missing.add(i);
        }
    }
    return missing;
}

private int getMaximum(Integer[] in) {
    int tmp = -1;
    for (int i = 0; i < in.length; i++) {
        if (tmp < in[i])
            tmp = in[i];
    }
    return tmp;
}

}
于 2013-08-22T11:57:51.920 回答
0

如果您在临时存储中对 id 进行排序，那么很容易找到第一个丢失的数字；

int arr[] = {0,1,2,5}; //think you've the sorted array now
int missing = arr.length; //would have the last id+1 if there is no missing id
for (int i = 0; i < arr.length; i++) {
    if (i != arr[i]) {
         missing = i;
         break;
    }
}
System.out.println(missing); //3 will be printed.
于 2013-08-22T12:28:41.360 回答
0

一种方法可能是维护一个包含已删除号码的并行数组。

Object[] data = ...;
Object[] delData = ...;

因此，每次插入/添加新数字时，您都需要检查该数字是否存在于并行数组中。

于 2013-08-22T11:54:31.037 回答
0

您有一些可能性，这是您必须自己决定的设计问题。只是一些替代方案：

  1. 最佳：删除时重新编号 ID，但需要有关引用外键的元信息。

  2. 如果数据是按 ID 排序的。未重新编号时的删除数：

    int deletions = data.length
                - (data.length == 0 ? 0 : data[data.length - 1][1]);

    通过二分查找，您可以找到已删除的孔（移位编号）。

  3. 无序。保留删除的数量。保持无限BitSet位data.length。

    或者一个Set<Integer>带有删除的选项。当集合变得太大时重新编号。（一组从-ID 到 to-ID 的范围会更好。）

于 2013-08-22T12:16:28.617 回答