Question

好的......我需要检查一个数组是否是一个完整的链。我会告诉你这意味着什么：

我有[5,3,2,0,4,1]。 N（数组大小）= 6，N-1 = 5.因此数组应包含数字0-5。然后我们从arr [0]开始。

arr [0] = 5，所以我们转到arr [5] = 1，arr [1] = 3，arr [3] = 0，这将我们带回arr [0]。

由于此数组没有转到EACH号码，因此它不是一个完整的链。我希望这有道理lol。

我应该在java中编写一个从arr [0]开始的方法，并按照我的说法进行操作，如果它击中了数组中的每个数字，那么它就是完整的链（true）。如果它回到已经命中的数字，那就不是（假）。

我理解这背后的逻辑......我无法实现它。我不知道如何使用循环来跟踪数字和索引......（我们应该使用循环）。

有人能指点我正确的方向吗？我不是在寻找代码，但是如果有人能解释我如何用这个来实现一个很棒的循环呢！

Answer 1

我会使用辅助boolean[]来告诉我们是否第二次点击索引。因为你显然需要一种方法来存储你已经看过的元素，并且由于该结构在最坏的情况下会占用线性空间，所以你也可以使用它。我会这样做

public static boolean arrayIsCompleteChain(int[] array) {
    boolean[] visited = new boolean[array.length];
    int index = 0;
    int steps = 0;

    // stop once we visit an index twice
    while(!visited[index]) {
        visited[index] = true; // mark index as visited
        index = array[index];  // go to the next index
        steps++;               // count this step
    }

    // if we made one step for every index, then the array is a complete chain
    if(steps == array.length) {
        return true;
    } else {
        return false;
    }

    // for anyone reading this who thinks to himself the "if" construct is
    // unnecessary: this is for didactic purposes
}

请注意，此方法不对输入执行任何验证检查，即它是否包含会使索引超出边界的元素，或者数组本身是否为null。如果你想要，那就很容易了。

Answer 2

您可以使用for循环迭代数组。这是一个例子：

int[] array = new int[4];
array[0] = 2;
array[1] = 5;
array[2] = 1;
array[3] = 8;

for(int i = 0; i<array.length; i++){
    System.out.println("The element in the array at position: "+ i +" is: " + array[i]);
}

你怎么看，我先声明并初始化数组。在for循环中，首先我声明并初始化一个临时变量（当for循环结束时该变量将被删除）为0（int i = 0）。接下来，我为“for循环”（i＆lt; array.length）编写结束表达式，此表达式确定for将何时完成，在这种情况下，for循环将继续运行，直到“i”小于array.length（4）。接下来，我将temp变量增加一（i ++）。

在这种情况下for循环的主体很简单（在给定位置（i）打印数组的元素）。但它可以是你想要的任何数组。

我希望你能理解。

PS：抱歉我的英文。我的第一语言是西班牙语。：d

Answer 3

你想要一个不在链中的元素的计数器（初始化为0）。您还需要一个与数组大小相同的布尔类型的数组。这种布尔类型的数组用于跟踪您是否有重复的元素。

为了使程序更快，在你的for循环中（用于迭代你的数组），当你发现一个元素超出你的链范围时，你增加计数器并打破循环。之后你只需检查计数器是否== 0.如果它是0，那么你的链就完成了，否则就不完整了。我希望这会有所帮助。

如何检查元素是否超出范围？检查元素是否是> = array.length或＆lt; 0（如果我理解你的问题吧）

我意识到你可能正在做一个家庭作业或类似的东西，我遗漏了大部分代码供你自己处理。下面是我如何使用布尔类型的数组来跟踪元素元素：

int[] arrayToCheck = new int[]{5, 3, 2, 0, 1, 1};
boolean[] arrayMarker = new boolean[arrayToCheck.length];

int count = 0;  // count the number out of the chain

for (int i : arrayToCheck) {
    // here you need to write code to check the element i is within
    // your range, if not, increment counter, break out

    if (arrayMarker[i] != true) {
        arrayMarker[i] = true;
    } else {
        count++;
        break;
    }
}

boolean completeChain = (count == 0) ? true : false;
System.out.println("is completeChain: " + completeChain);

Answer 4

假设数字是唯一的：

public int sum(int[] arr) {
    int ret = 0;
    for (int i : arr) {
        ret += arr[i];
    }
    return ret;
}

int[] arr = { 5, 3, 2, 0, 4, 1 };
int tmp = arr[0];
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum += arr[tmp];
    tmp = arr[tmp];
}
System.out.println(sum == sum(arr));

Answer 5

我将描述一个方法，该方法在给定的int数组中返回提供的索引位置的值。

public static int getAtPosition(int nextPosition, int... elements) {
    return elements[nextPosition];
}

本质上，我用nextPosition的任何值都用于索引数组。

接下来考虑一下，您使用nextPosition开始播放arr[0]，如果与方法调用相结合，则会产生下一个位置值1。

你也正确地观察到它振荡，这使得它成为无效链。

现在，这里的诀窍是选择一个数据结构来存储我们看过的元素，并防止我们再次触发重复。让我们使用Set<Integer>来实现这一点，因为我们可以add相对便宜，并且Set的接口强制它返回true当且仅当未添加此元素时到先前的设定。

public static boolean invalidChain(Set<Integer> values, int index) {
    return !values.add(index);
}

解释：

给定一组整数，我添加了我刚看到的索引位置。
如果成功添加索引位置，则返回false - 因为成功的add()表示该值从未放入集合中。
如果索引位置未成功添加，我返回true - 原因与上述相反。

鉴于所有这些，您现在必须创建一个利用布尔invalidChain和int getAtPosition的循环。提示：invalidChain是您应该在循环中检查的唯一条件。

循环命中数组的每个元素？

5 个答案: