Question

我正在尝试编写一个接受数组的方法，并找到彼此相邻的任何相等元素，并返回最大数量的出现次数。例如，int值为{1,2,3,4,4,5,5}的数组将返回值3.具有{1,1,1,2,2,3,3,3,3,5,6,7}的数组将返回值4。我尝试了几种不同的方法，但我很挣扎。任何帮助，将不胜感激。谢谢。继承了我到目前为止的代码 -

public class EqualElements 
{
    public static void consecutiveEqualElements(int [] elements)
    {
        int occurances = 0;
        int temp = 0;
        int count = 0;

        for (int index = 0; index < elements.length; index++)
        {                   
            if(elements[index] == elements[temp])
            {
                count++;
                temp++;
                index--;
            }
            else
            {       
            }
        }
        System.out.println(count);
    }

    public static void main(String[] args) 
    {
        int [] numbers = {1,2,2,3,4,5,6,7};
        consecutiveEqualElements(numbers);
    }
}

Answer 1

这是查看连续数字的数组的更好方法。这适用于未排序和排序的数组。

public static int consecutiveEqualElements(int [] elements) {
    int currentNum = elements[0];
    int currentConsecutive = 1;
    int maxConsecutive = 1;
    for (int i = 1; i < elements.length; i++) {
        if (elements[i] == currentNum) {
            currentConsecutive++;
            maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
        } else {
            currentNum = elements[i];
            currentConsecutive = 1;
        }
    }
    return maxConsecutive;
}

Answer 2

最简单的方法是使用hashmap：

Map map = new HashMap();

现在遍历数组并将每个整数与其计数放在一起。

map.put(yourIntValue, map.get(1) + 1); // if it is already stored with a value.

初始条件：

map.put(yourIntValue,0);

然后再次迭代并找到最大值。

Answer 3

你已经在遍历数组了 - 这很好。当你这样做时，你会对两个数字感兴趣：

迄今为止最长的一次。这将是你最后的答案。
当前运行的长度。你需要这个来更新最长的运行。

我们为这些变量创建了两个变量：maxCount和count。在循环期间，每当我们遇到两个相等的连续元素时，我们递增count。为了确保maxCount始终是最新的，我们将其设置为目前为止最长的最大值和当前长度。当下一个元素与前一个元素不同时，我们将count重置为1，因为这是下一次运行的开始。

public static void consecutiveEqualElements(int [] elements) {
    int count = 1;
    int maxCount = 1;

    for (int index = 1; index < elements.length; index++) {
        if (elements[index] == elements[index - 1]) {
            count++;
            maxCount = Math.max(maxCount, count);
        } else {
            count = 1;
        }
    }

    System.out.println(maxCount);
}

注意：此方法假定elements不是null或为空。如果有必要，你可以单独处理这些案件。

Answer 4

我的解决方案如下：

public class EqualElements {

    public static void consecutiveEqualElements(int[] elements) {

            // Saves the maximal number of consecutive number with the
            // same numeric value
            int occurances = 0;

            // Counts how many numbers with the same value stands right
            // behind each other
            int count = 1;

            // Run from the second index because of the in the body following
            // if-clause
            for (int index = 1; index < elements.length; index++) {

                    // In case the current and the previous element
                    // have the same numeric value
                    if (elements[index] == elements[index - 1]) {
                            // Increase the count (which is initialised with 1)
                            // And save the maximal number of consecutive numbers
                            // with the same value in occurances
                            count++;
                            occurances = Math.max(occurances, count);
                    } else {
                         // If the two numbers differ, reset the counter
                         count = 1;

                    }
             }
             System.out.println(occurances);

}

public static void main(String[] args) {
    int[] numbers = { 1, 2, 2, 2, 3, 4, 5, 2, 6, 7 };

    consecutiveEqualElements(numbers);
}
}

我的示例返回正确的解决方案3.它不计算最后2个，因为它不连续。

Answer 5

在遍历数组时，将每个元素与前一个元素进行比较。如果两个元素相等，则增加您看到的连续相等值的数量。如果它们不相等，请检查您是否找到了新的最大值，然后将该计数器重置为0.

public static int consecutiveEqualElements(int[] elements) {
    int max = 0;
    int consecutive = 1;

    for (int i = 1; i < elements.length; i++) {
        if (elements[i] == elements[i-1]) {
            consecutive++;
        } else {
            if (consecutive > max) {
                max = consecutive;
            }
            consecutive = 1;
        }
    }

    if (consecutive > max) {
        return consecutive;
    } else {
        return max;
    }
}

请注意，该方法返回一个值而不是将其打印出来。这使得该方法更加灵活，因为您可能并不总是希望它打印到标准输出。

如何搜索阵列中彼此相邻的相等元素

5 个答案: