java - 相同整数的队列

Question

我试图在数组中找到一个具有相同值的整数队列，我应该使用 ArrayList 或 List，问题是 ArrayList 的使用在我的代码中几乎没有用处，你能帮我解决如何使我的代码更简单吗？

• 明确为什么我需要这个 - 这是学校作业

例如，如果给定的数组为 5,5,5,3,2
ArrayList 应包含 5,5,5
如果数组是 5,5,3,3
老师似乎并不关心列表中是否有 5,5 还是 3,3

我的代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;


public class UlohaA6 {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sc = new Scanner(System.in);
    Random rnd = new Random();
    int arr[] = new int[sc.nextInt()];
    for(int i = 0;i<arr.length;i++){
        arr[i]=rnd.nextInt(10)+1;
    }
    System.out.println(Arrays.toString(arr));
    sc.close();
    ArrayList<Integer> list = new ArrayList<>();
    int x = 0;
    int xmax = 0;
    int imax = 0;
    boolean first = true;
    for(int i =0;i<arr.length;i++){
        if(i<arr.length-1)
            if(arr[i]==arr[i+1]){
                if(first==true){
                    x++;
                    first=false;
                }
                x++;
                if(x>xmax){
                    xmax=x;
                    imax=i+1;
                }
            }
            else{
                first=true;
                x=0;
            }
    }
    System.out.println(imax);
    System.out.println(xmax);
    if(xmax!=0&&imax!=0)
        for(int i = imax+1-xmax;i<=imax;i++)
            list.add(arr[i]);
    System.out.println(list.toString());
    sc.close();
}

}

Answer 1

could you please help me out how to make my code simpler ?

嗯，这并不是 SO 的真正用途，因为你的代码可以工作，我有点想知道问题到底是什么。

问题的重要部分是“理解”解决方案的工作原理。如果你能理解“解决方案”，那么有很多方法可以让它变得更简单，事实上，我自己的大部分工作都是在尝试减少和清理问题之前“理解”问题的解决方案......有时，如果它有效，就不要管它。

但是，如果您想“简化”解决方案，首先，您应该首先尝试“可视化”问题，因此，假设输入为{5, 5, 5, 3, 2}，我们可以循环遍历这些值，从1开始，并根据“上一个”值测试“当前”值，它可能看起来像这样...

+=======+==================+==============+=======+
| index | input[index - 1] | input[index] | match |
+=======+==================+==============+=======+
|     1 |                5 |            5 | true  |
+-------+------------------+--------------+-------+
|     2 |                5 |            5 | true  |
+-------+------------------+--------------+-------+
|     3 |                5 |            3 | false |
+-------+------------------+--------------+-------+
| ....

这是for循环的基本表示

为什么从1开始？好吧，您可以从 0 开始并针对当前值和下一个值进行测试，但您仍然需要考虑溢出数组末尾的可能性，这只是避免该问题的简单方法。

但是，代码看起来是什么样的？

嗯，它“可能”看起来像这样......

int[] input = new int[]{5, 5, 5, 3, 2};
List<Integer> matches = new ArrayList<Integer>(input.length);
for (int index = 1; index < input.length; index++) {
    if (input[index] == input[index - 1]) {
        // We've not added the first element yet
        if (matches.isEmpty()) {
            matches.add(input[index]);
        }
        matches.add(input[index]);
    } else {
        // No point going forward
        break;
    }
}
System.out.println(matches);

这里的技巧是，将“第一个”元素放入List中，因为当我们进行第一次匹配时，里面什么都没有。有几种方法可以做到这一点，这只是其中一种。

捕获所有组怎么样？好吧，这变得有点复杂，因为您需要一种更好的方法来管理各种 List 并知道何时需要丢弃一个列表并创建一个新列表，但是，它可能看起来像......

int[] input = new int[]{5, 5, 5, 3, 3};
List<List<Integer>> allMatches = new ArrayList<>(5);
List<Integer> matches = null;
for (int index = 1; index < input.length; index++) {
    if (input[index] == input[index - 1]) {
        if (matches == null) {
            matches = new ArrayList<Integer>(input.length);
            // We need the previous value
            matches.add(input[index]);
        }
        matches.add(input[index]);
    } else {
        if (matches != null) {
            allMatches.add(matches);
        }
        matches = null;
    }
}
if (matches != null) {
    allMatches.add(matches);
}
System.out.println(allMatches);

实际上，这只是将两个循环减少为一个。