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

能否请您帮我简化代码？

好吧，这不是SO的真正意义，并且由于您的代码有效，所以我很想知道问题的实质。

问题的重要部分是“了解”解决方案的工作方式。如果您能够理解“解决方案”，那么可以通过多种方式简化它，实际上，在我尝试减少并清理问题之前，我的许多工作都是“理解”问题的解决方案。 ..有时，如果可行，就别管它了。

但是，如果您想“简化”解决方案，首先，应该首先尝试“可视化”问题，因此，假设input中的{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-loop

的基本表示形式

为什么从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并知道何时需要丢弃一个并创建一个新的，但是，它看起来可能类似于... < / p>

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);

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

Answer 2

我刚刚修改了代码，使其更简洁易读。另外，我删除了该列表，因为它除了打印外没有其他功能，所以我自己创建了输出。如果愿意，您仍然可以使用List，这样就不需要最后一部分了，它基本上是在构建类似于您的输出的输出字符串：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    Random rnd = new Random();
    int arr[] = new int[sc.nextInt()];
    sc.close();
    for(int i = 0;i<arr.length;i++){
        arr[i]=rnd.nextInt(10)+1;
    }
    System.out.println(Arrays.toString(arr));

    // The current number sequence
    int currentNumber = -1;
    // The current number of occurrences of the sequence
    int occurs = 0;
    // The maximum occurrences of a sequence
    int maxOccurs = 0;
    // The number that occurrences the most
    int maxNumber = -1;

    // Running on all of the array items and find the maximum sequence
    for (int currItem : arr) {
        // If the sequence was changed
        if (currItem != currentNumber) {
            // Check if the sequence that just ended is bigger than the biggest right now
            if (maxOccurs < occurs) {
                maxOccurs = occurs;
                maxNumber = currentNumber;
            }

            // Anyway, reset the occurrences number and current number
            occurs = 1;
            currentNumber = currItem;

        // If the sequence was NOT changed
        } else {
            // Increment the occurrences
            occurs++;
        }
    }

    // Check if the sequence that just ended is bigger than the biggest right now again - maybe it is at the end of the array
    if (maxOccurs < occurs) {
        maxOccurs = occurs;
        maxNumber = currentNumber;
    }

    // Create the output string. Note - I did it only to match the output of your list 
    StringBuilder output = new StringBuilder("[");

    for (int i = 0; i < maxOccurs; i++) {
        output.append(maxNumber);

        if (i < maxOccurs - 1) {
            output.append(",");
        }
    }

    output.append("]");

    System.out.println(output.toString());
}

干杯，戈兰

相同整数的队列

2 个答案: