Java 编写一个程序，获取整数数组/arraylist，并查找条目相等的最长子数组/arraylist

我试图在一本书中解决一个问题。我在Java书中编程访谈的元素中发现了这个问题

解决方案： 例如，如果arraylist=[1,2,2,0,0,0,1,1,1,1] 输出必须为=[1,1,1,1,1]

我的代码不起作用：

public class SubArraySameEntry {

 public static int subArr(List<Integer> arr) {



      int count = 1;
      int e=0;

      for (int i = 1; i < arr.size(); i++) {
           int m = 0;

           if (arr.get(i - 1).equals(i)) {
                count++ ;
           }
           if (count > m) {
                m = count;
                e = arr.get(i);
           }
           if (!arr.get(i - 1).equals(i)) count =1;

      }

      return count;
 }

 public static void main(String[] args) {
      List<Integer> arr = new ArrayList<>(Arrays.asList(1, 2, 2, 0, 0, 0, 1, 1, 1, 1));
      System.out.println(arr.toString());
      int newArr = subArr(arr);
      for (int i = 0; i < newArr; i++) {
           System.out.print(arr.get(i) + " ");

      }
 }
}

公共类子阵列{
公共静态int分区（列表arr）{
整数计数=1；
int e=0；
对于（int i=1；im）{
m=计数；
e=arr.get（i）；
}
如果（！arr.get（i-1）.等于（i））计数=1；
}
返回计数；
}
公共静态void main（字符串[]args）{
listarr=newarraylist（Arrays.asList（1,2,2,0,0,0,1,1,1,1））；
System.out.println（arr.toString（））；
int newArr=子雷达（arr）；
for（int i=0；i

我试过了，花了太多时间，但无法解决问题。

关于您的代码，排序（

Collections.sort（arr）；

）将完全阻止您找到解决方案

我会在伪代码方面提供帮助

Given a counter c
A max counter m
A variable for the max element, e
And an array a
For every element in the array a
    If the element matches the previous element
        increment the count c, and:
          if the count c > m:
            set m to c, and e to the current value
    If it doesn't match the previous, reset the count to 1

Then after all this, the result is e, c times

---

你能解释一下输出吗？我希望问题的标题是

[1,2,3,4]

，因为这是具有相等连续数的子阵列的最大长度。为什么它应该是

[1,1,1,1,1,1]

？标题说查找最长子数组的长度，但示例返回子数组本身。@Tunaki我本来希望返回的是

4

，因为这是最长子数组的长度。最快的解决方案（无排序）：构建

元素的映射到
计数
。查找/记住具有最高
计数的
元素
。将结果生成为
count
元素
的副本。只是为了好玩：
Map collect=arr.stream（）.collect（Collectors.groupingBy（Function.identity（），Collectors.counting（））；collect.entrySet（）.stream（）.max（（e1，e2）->e1.getValue（）.compareTo（e2.getValue（））.ifPresent（v->System.out.println（“Value”+v.getKey（）+“exists”+v.getValue（）+“times”））
->输出“Value 1存在5次”。然后做一个循环，打印1五次。你看了指定的“解决方案”（问题的第二段）了吗？根据这一点，“子阵列”不是由连续的相等值构建的，只是相等的值，即输入有五个1，但只有四个1，但答案仍然是五个1。所以，只有先调用
sort（）
，您的代码才能得到正确的结果。@weston我需要帮助来解决这个问题。但是谢谢你的算法你是对的，它很简单，但是你这样做是为了练习，那么有人为你做这件事有什么意义呢？我不知道你为什么认为我反应不好，或者认为我不是，我是想帮你。因此，您对我的算法的解释的主要错误是，
m
需要在循环之外定义，
arr.get（i-1）。equals（i）
需要
arr.get（i-1）。equals（arr.get（i））
抱歉，我们中的一些人假设问题是针对“连续子数组”，您可以先排序，然后再排序，但我不知道是否有更好的方法（可能是）。