Question

我希望创建一个函数来检查数组中是否有任何数字存在三次或更多次。

例如这个数组：

4 - 6 - 14 - 8 - 6 - 15 - 14 - 15 - 13 - 10 -

不应输出任何内容，但是：

4 - 6 - 14 - 8 - 6 - 15 - 14 - 15 - 14 - 10 -

如果systemout打印输出数字14存在三次。

应该怎么做？我开始制作for循环，

for(int i=0; i<array.length; i++){
}

然后我卡住了，我怎么能做到这一点？

Answer 1

for (int i = 0; i < array.length; i++) {
    int count = 0;
    for (int j = 0; j < array.length; j++) {
        {
            if (array[i] == array[j]) {
                count++;
            }

        }
        if (count >= 3) {
            System.out.println(array[i] + " exists " + count
                    + " times.");
        }
    }
}

该程序输出n次（对于n> = 3）a元素存在n次。您应该添加一个逻辑来检查是否已经检查过某个元素。但也许你现在可以自己继续。提示：使用HashMap或List ...或....

其他需要Integer[]代替int[]而且速度更快的解决方案：

Integer[] array = new Integer[] { 1, 2, 1, 1, 1, 3, 3, 3, 2, 2, 4, 5 };

for (int i = 0; i < array.length; i++) {
    int count = 0;
    if (array[i] != null) {
        int compare = array[i].intValue();
        for (int j = 0; j < array.length; j++) {

            if (array[j] != null) {
                if (compare == array[j]) {
                    array[j] = null;
                    count++;
                }
            }

        }
        if (count >= 3) {
            System.out
                    .println(compare + " exists " + count + " times.");
        }
    }
}

输出：

1 exists 4 times.
2 exists 3 times.
3 exists 3 times.

首先将数组复制到Integer []数组中。后一种算法也解决了输出问题。

Answer 2

只需将hashmap个数字作为关键字，将出现次数作为地图值。在for循环之后，您可以迭代地图并打印出现值大于3的数字

Answer 3

如果下两个元素相同，您可以对数组进行排序，然后检查每个新元素。如果他们这样做 - 保存元素。如果他们没有重置计数器并转到下一个元素

Answer 4

您可以从排序数组开始，然后开始用i + 1检查i，如果相等则增加计数器，否则将其设置为0，重复此操作直到计数器不等于2。

private static int findTree(int[] array){


        Arrays.sort(array);

        int i = 0;
        int counter = 0;

        while (counter != 2 && i < array.length - 1) {

            if(array[i] == array[i+1]){
                counter++;
            } else {
                counter =0;
            }

            i++;
        }

        if(counter == 2){
            return array[i];
        }

        return -1;
    }

编辑：

更棘手的alg，找到给定数字的n个匹配。

假设您必须找到至少n个相等的数字。

如果我们首先对数组进行排序，我们将按顺序排列所有元素，因此如果我们需要找到四（n）个相等元素，我们可以取一个（i）并检查距离他三个空格的元素（i） + N-1）。如果这个元素相等，我们在数组中的i元素下找到了我们的解决方案，如果不是，我们可以通过递增i（i ++）来移动到下一个。

这是怎么回事：

private static int findN(int[] array, int n){

        if(n == 0) {
         return -1;
        }

        Arrays.sort(array);

        n--; //We reduce our n searched element because in i we already have one

        int i = 0;
        boolean found = false;

        while (found == false && i < array.length - n) {
            if(array[i] == array[i+n]) { //remember that we have reduced the n by one.
                found = true;
            } else {
                i++;
            }
        }

        if(found) {
           return array[i];
        }

        return -1;
    }

Answer 5

如果一个数字存在4次怎么办？

没有输出，因为3不是4，你想要3
1x输出，因为你搜索至少3次点击
2x输出，因为你可以显示3 三元组

Answer 6

如果多于一个数字存在3次或更多次怎么办？

报告每个号码
报告第一个，仅

Answer 7

以下是一般情况的解决方案：在列表中搜索每个元素是否存在以下X出现。

public class TripleTest
{
    public static void main (String[] args)
    {
        int[] list = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
        findCount (list, 3);
    }

    public static void findCount (int[] list, int count)
    {
        for (int i = 0; i <= list.length - count; ++i)
        {
            int elem = list [i];
            boolean hit = findWhatCountFrom (list, i + 1, elem, count - 1);
            if (hit) 
                System.out.println ("hit: " + elem);
        }
    }

    public static boolean findWhatCountFrom (int[] list, int idx, int what, int count)
    {
        if (count == 0)
            return true;
        if (idx == list.length) 
            return false;
        return findWhatCountFrom (list, idx + 1, what, count - ((list [idx] == what) ? 1 : 0));
    }
}

在一个解决方案之后它不会停止，所以也许你想改变它。要求不明确。

，而不是返回值，解决方案被打印出来 - 这有点难看。

通过将其从int []更改为Generics来改进解决方案。也许从Array到List。

Java：检查数组中是否存在三个或更多匹配项

7 个答案: