Question

我需要从未排序的数组中获取最小的未使用数字。我无法对数组进行排序，因为这只是一个测试程序，在实际程序中，我将从一组对象中获取值。

因此，在尝试获取最小的未使用数字时，我设法得到了未使用数字的列表。它非常适合我在程序中编写的第一个随机数，但第二次输出错误。

这是我试过的代码

class smallestUnusedNumberTest {
    public static void main(String args[]) {
        int[] testArray = {1, 5, 7, 11, 4, 8};
        int largest = 1;
        int i;
        for(i = 0; i < testArray.length; i++) {
            if(testArray[i] > largest) {
                largest = testArray[i];
            }
        }
        for(i = 1; i < largest; i++) {
            for(int j = 0; j < testArray.length; j++) {
                if(i == testArray[j]) {
                    i++;
                }
            }
            System.out.println(i);
        }
    }
}

，我得到的输出是

我得到5，已经存在于数组中。我使用for循环从数组中获取最大数字。但是，我无法找出正确的逻辑。

如何从阵列中获取正确的未使用数字？我需要按升序输出。

Answer 1

算法的逻辑存在问题：当您找到匹配项时，在内部循环内增加i，但继续循环。因此，当您在4之后找到5时，会将i从4增加到5，但您永远不会回到数组的开头看看是否有一些早期的元素是5。

要解决此问题，请在外部循环中定义boolean变量，最初将其设置为false，然后在找到{{1}时将其设置为内部循环中的true }};找到匹配后突然退出。

在内循环后检查你的布尔变量。如果是i == testArray[j]，那么号码就在那里，所以你不应该打印任何东西。否则，请打印该号码。

Answer 2

使用标志来了解该值是否未使用。

    public static void main(String[] args) {
        int[] testArray = {1, 5, 7, 11, 4, 8};
        int largest = 1;
        int i;
        for(i = 0; i < testArray.length; i++) {
            if(testArray[i] > largest) {
                largest = testArray[i];
            }
        }
        for(i = 1; i < largest; i++) {
            boolean unused = true;
            for(int j = 0; j < testArray.length; j++) {
                if(i == testArray[j]) {
                    unused = false;
                    break;
                }
            }
            if (unused)
                System.out.println(i);
        }
    }

结果：

enter image description here

Answer 3

希望这会有所帮助......

package com.test;

import java.util.Arrays;

public class SmallestUnused {

public static void main(String[] args) {
    int[] testArray = {1, 5, 7, 11, 4, 8};
    Arrays.sort(testArray);
    int smallest = testArray[0];
    int largest = testArray[testArray.length-1];
    int smallestUnused = largest + 1;
    System.out.println("smallest: "+smallest);
    System.out.println("largest: "+largest);
    if(smallest>1){
        smallestUnused = 1;
    }else{
        for(int i=2; i<largest; i++){
            if(Arrays.binarySearch(testArray, i)<0){
                smallestUnused = i;
                break;
            }
        }
    }
    System.out.println("Smallest unused: "+smallestUnused);
}

}

Answer 4

如果你创建一个子方法，这将使你的生活更轻松

//returns true if the array parameter contains num, false if not
private boolean contains(int num, int[] array) {
  // fill this in
}

Answer 5

您可以通过简化代码来减少循环 -

    public static void main(String[] args) {
        int[] testArray = {1, 5, 7, 11, 4, 8};
        int i = 0;
        while (true) {
            i++;
            boolean small = false;
            boolean unused = true;
            for (int j : testArray) {
                if (i == j) {
                    unused = false;
                    break;
                } else if (i < j) {
                    small = true;
                }
            }
            if (small && unused) {
                System.out.println(i);
            } else if (!small && unused) {
                break;
            }
        }
    }

Answer 6

这可以通过四个步骤解决，没有任何嵌套循环。

在testArray中找到最大值。你已经有了代码。
创建一个新的布尔数组，大小最大+ 1，所有值都初始化为false。我们称之为usedValues []。
再次循环执行testArray。对于testArray的每个元素，设置usedValues [testArray [i]] = true。
最后，循环使用usedValues []。 usedValues [i] == false的第一个元素的索引是testArray中未使用的最低值。

如果你说要按升序打印所有未使用的数字，你可以通过usedValues数组进行一次传递，只需打印所有元素的索引，其中usedValues [i] == false。

从java中未排序的数组中获取未使用的数字列表

6 个答案: